From 1ec14118fecf697b04a5f2f1538a5829b7ebee02 Mon Sep 17 00:00:00 2001 From: Thomas Krijnen Date: Wed, 17 Jun 2015 11:04:28 +0000 Subject: [PATCH] Introduce specific exception for out of range attribute indexing --- src/ifcexpressparser/header.py | 6 +- src/ifcexpressparser/templates.py | 2 +- src/ifcparse/Ifc2x3.cpp | 234 +++++------ src/ifcparse/Ifc2x3.h | 606 ++++++++++++++--------------- src/ifcparse/Ifc4.cpp | 252 ++++++------ src/ifcparse/Ifc4.h | 354 ++++++++--------- src/ifcparse/IfcEntityDescriptor.h | 2 +- src/ifcparse/IfcException.h | 18 +- src/ifcparse/IfcParse.cpp | 14 +- src/ifcparse/IfcUtil.cpp | 2 +- 10 files changed, 748 insertions(+), 742 deletions(-) diff --git a/src/ifcexpressparser/header.py b/src/ifcexpressparser/header.py index da29c0e262..51f4a89242 100644 --- a/src/ifcexpressparser/header.py +++ b/src/ifcexpressparser/header.py @@ -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 diff --git a/src/ifcexpressparser/templates.py b/src/ifcexpressparser/templates.py index 810871923b..2cd9722cd9 100644 --- a/src/ifcexpressparser/templates.py +++ b/src/ifcexpressparser/templates.py @@ -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();" diff --git a/src/ifcparse/Ifc2x3.cpp b/src/ifcparse/Ifc2x3.cpp index 713257081b..5406ae5c6b 100644 --- a/src/ifcparse/Ifc2x3.cpp +++ b/src/ifcparse/Ifc2x3.cpp @@ -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; } diff --git a/src/ifcparse/Ifc2x3.h b/src/ifcparse/Ifc2x3.h index 0f89dfa964..963ae54e08 100644 --- a/src/ifcparse/Ifc2x3.h +++ b/src/ifcparse/Ifc2x3.h @@ -6610,9 +6610,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); } bool is(Type::Enum v) const; Type::Enum type() const; @@ -6647,9 +6647,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 @@ -6678,9 +6678,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; @@ -6744,9 +6744,9 @@ public: IfcDateTimeSelect* FixedUntilDate() const; void setFixedUntilDate(IfcDateTimeSelect* v); virtual unsigned int getArgumentCount() const { return 6; } - 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_ENTITY_INSTANCE; case 5: 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::IfcAppliedValueSelect; case 3: return Type::IfcMeasureWithUnit; case 4: return Type::IfcDateTimeSelect; case 5: return Type::IfcDateTimeSelect; } 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"; } 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_ENTITY_INSTANCE; case 5: 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::IfcAppliedValueSelect; case 3: return Type::IfcMeasureWithUnit; case 4: return Type::IfcDateTimeSelect; case 5: return Type::IfcDateTimeSelect; } 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"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } IfcTemplatedEntityList< IfcReferencesValueDocument >::ptr ValuesReferenced() const; // INVERSE IfcReferencesValueDocument::ReferencingValues IfcTemplatedEntityList< IfcAppliedValueRelationship >::ptr ValueOfComponents() const; // INVERSE IfcAppliedValueRelationship::ComponentOfTotal @@ -6802,9 +6802,9 @@ public: std::string Description() const; void setDescription(std::string v); virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_STRING; case 4: 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::IfcAppliedValue; case 1: return Type::IfcAppliedValue; case 2: return Type::IfcArithmeticOperatorEnum; case 3: return Type::IfcLabel; case 4: return Type::IfcText; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ComponentOfTotal"; case 1: return "Components"; case 2: return "ArithmeticOperator"; case 3: return "Name"; case 4: return "Description"; } 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_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_STRING; case 4: 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::IfcAppliedValue; case 1: return Type::IfcAppliedValue; case 2: return Type::IfcArithmeticOperatorEnum; case 3: return Type::IfcLabel; case 4: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ComponentOfTotal"; case 1: return "Components"; case 2: return "ArithmeticOperator"; case 3: return "Name"; case 4: 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; @@ -6846,9 +6846,9 @@ public: std::string Identifier() const; void setIdentifier(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_ENTITY_INSTANCE; 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; } throw IfcParse::IfcException("argument out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcText; case 1: return Type::IfcDateTimeSelect; case 2: return Type::IfcLabel; case 3: return Type::IfcLabel; case 4: return Type::IfcText; case 5: return Type::IfcLabel; case 6: return Type::IfcIdentifier; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Description"; case 1: return "ApprovalDateTime"; case 2: return "ApprovalStatus"; case 3: return "ApprovalLevel"; case 4: return "ApprovalQualifier"; case 5: return "Name"; case 6: 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_ENTITY_INSTANCE; 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; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcText; case 1: return Type::IfcDateTimeSelect; case 2: return Type::IfcLabel; case 3: return Type::IfcLabel; case 4: return Type::IfcText; case 5: return Type::IfcLabel; case 6: return Type::IfcIdentifier; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Description"; case 1: return "ApprovalDateTime"; case 2: return "ApprovalStatus"; case 3: return "ApprovalLevel"; case 4: return "ApprovalQualifier"; case 5: return "Name"; case 6: return "Identifier"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } IfcTemplatedEntityList< IfcApprovalActorRelationship >::ptr Actors() const; // INVERSE IfcApprovalActorRelationship::Approval IfcTemplatedEntityList< IfcApprovalRelationship >::ptr IsRelatedWith() const; // INVERSE IfcApprovalRelationship::RelatedApproval @@ -6870,9 +6870,9 @@ public: IfcActorRole* Role() const; void setRole(IfcActorRole* 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_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcActorSelect; case 1: return Type::IfcApproval; 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 "Actor"; case 1: return "Approval"; case 2: return "Role"; } 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_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcActorSelect; case 1: return Type::IfcApproval; 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 "Actor"; case 1: return "Approval"; case 2: return "Role"; } 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; @@ -6889,9 +6889,9 @@ public: IfcApproval* Approval() const; void setApproval(IfcApproval* 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::IfcProperty; case 1: return Type::IfcApproval; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ApprovedProperties"; case 1: return "Approval"; } 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::IfcProperty; case 1: return Type::IfcApproval; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ApprovedProperties"; case 1: return "Approval"; } 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; @@ -6921,9 +6921,9 @@ public: std::string Name() const; void setName(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_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::IfcApproval; case 1: return Type::IfcApproval; case 2: return Type::IfcText; case 3: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelatedApproval"; case 1: return "RelatingApproval"; case 2: return "Description"; case 3: return "Name"; } 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_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::IfcApproval; case 1: return Type::IfcApproval; case 2: return Type::IfcText; case 3: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelatedApproval"; case 1: return "RelatingApproval"; case 2: return "Description"; case 3: 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; @@ -6955,9 +6955,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; @@ -7142,9 +7142,9 @@ public: int YearComponent() const; void setYearComponent(int v); virtual unsigned int getArgumentCount() const { return 3; } - 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; } throw IfcParse::IfcException("argument out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDayInMonthNumber; case 1: return Type::IfcMonthInYearNumber; case 2: return Type::IfcYearNumber; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DayComponent"; case 1: return "MonthComponent"; case 2: return "YearComponent"; } 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; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDayInMonthNumber; case 1: return Type::IfcMonthInYearNumber; case 2: return Type::IfcYearNumber; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DayComponent"; case 1: return "MonthComponent"; case 2: return "YearComponent"; } 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; @@ -7197,9 +7197,9 @@ public: std::string Name() const; void setName(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_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::IfcLabel; case 2: return Type::IfcCalendarDate; case 3: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Source"; case 1: return "Edition"; case 2: return "EditionDate"; case 3: 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_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::IfcLabel; case 2: return Type::IfcCalendarDate; case 3: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Source"; case 1: return "Edition"; case 2: return "EditionDate"; case 3: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } IfcTemplatedEntityList< IfcClassificationItem >::ptr Contains() const; // INVERSE IfcClassificationItem::ItemOf bool is(Type::Enum v) const; @@ -7221,9 +7221,9 @@ public: std::string Title() const; void setTitle(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_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; 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::IfcClassificationNotationFacet; case 1: return Type::IfcClassification; 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 "Notation"; case 1: return "ItemOf"; case 2: return "Title"; } 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_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcClassificationNotationFacet; case 1: return Type::IfcClassification; 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 "Notation"; case 1: return "ItemOf"; case 2: return "Title"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } IfcTemplatedEntityList< IfcClassificationItemRelationship >::ptr IsClassifiedItemIn() const; // INVERSE IfcClassificationItemRelationship::RelatedItems IfcTemplatedEntityList< IfcClassificationItemRelationship >::ptr IsClassifyingItemIn() const; // INVERSE IfcClassificationItemRelationship::RelatingItem @@ -7242,9 +7242,9 @@ public: IfcTemplatedEntityList< IfcClassificationItem >::ptr RelatedItems() const; void setRelatedItems(IfcTemplatedEntityList< IfcClassificationItem >::ptr 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_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::IfcClassificationItem; case 1: return Type::IfcClassificationItem; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelatingItem"; case 1: return "RelatedItems"; } 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_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::IfcClassificationItem; case 1: return Type::IfcClassificationItem; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelatingItem"; case 1: return "RelatedItems"; } 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; @@ -7259,9 +7259,9 @@ public: IfcTemplatedEntityList< IfcClassificationNotationFacet >::ptr NotationFacets() const; void setNotationFacets(IfcTemplatedEntityList< IfcClassificationNotationFacet >::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::IfcClassificationNotationFacet; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "NotationFacets"; } 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::IfcClassificationNotationFacet; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "NotationFacets"; } 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; @@ -7276,9 +7276,9 @@ public: std::string NotationValue() const; void setNotationValue(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 "NotationValue"; } 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 "NotationValue"; } 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; @@ -7303,9 +7303,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; @@ -7331,9 +7331,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; @@ -7482,9 +7482,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_ENTITY_INSTANCE; 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::IfcDateTimeSelect; 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_ENTITY_INSTANCE; 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::IfcDateTimeSelect; 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< IfcConstraintClassificationRelationship >::ptr ClassifiedAs() const; // INVERSE IfcConstraintClassificationRelationship::ClassifiedConstraint IfcTemplatedEntityList< IfcConstraintRelationship >::ptr RelatesConstraints() const; // INVERSE IfcConstraintRelationship::RelatingConstraint @@ -7528,9 +7528,9 @@ public: IfcLogicalOperatorEnum::IfcLogicalOperatorEnum LogicalAggregator() const; void setLogicalAggregator(IfcLogicalOperatorEnum::IfcLogicalOperatorEnum 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_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 4: 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::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcConstraint; case 3: return Type::IfcConstraint; case 4: return Type::IfcLogicalOperatorEnum; } 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 "RelatingConstraint"; case 3: return "RelatedConstraints"; case 4: return "LogicalAggregator"; } 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_AGGREGATE_OF_ENTITY_INSTANCE; case 4: 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::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcConstraint; case 3: return Type::IfcConstraint; case 4: return Type::IfcLogicalOperatorEnum; } 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 "RelatingConstraint"; case 3: return "RelatedConstraints"; case 4: return "LogicalAggregator"; } 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; @@ -7547,9 +7547,9 @@ public: IfcEntityList::ptr RelatedClassifications() const; void setRelatedClassifications(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_ENTITY_INSTANCE; 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::IfcConstraint; case 1: return Type::IfcClassificationNotationSelect; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ClassifiedConstraint"; case 1: return "RelatedClassifications"; } 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_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::IfcConstraint; case 1: return Type::IfcClassificationNotationSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ClassifiedConstraint"; case 1: return "RelatedClassifications"; } 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; @@ -7584,9 +7584,9 @@ public: IfcTemplatedEntityList< IfcConstraint >::ptr RelatedConstraints() const; void setRelatedConstraints(IfcTemplatedEntityList< IfcConstraint >::ptr 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_ENTITY_INSTANCE; 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::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcConstraint; case 3: return Type::IfcConstraint; } 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 "RelatingConstraint"; case 3: return "RelatedConstraints"; } 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_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::IfcConstraint; case 3: return Type::IfcConstraint; } 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 "RelatingConstraint"; case 3: return "RelatedConstraints"; } 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; @@ -7607,9 +7607,9 @@ public: IfcAheadOrBehind::IfcAheadOrBehind Sense() const; void setSense(IfcAheadOrBehind::IfcAheadOrBehind v); virtual unsigned int getArgumentCount() const { return 3; } - 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_ENUMERATION; } throw IfcParse::IfcException("argument out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcHourInDay; case 1: return Type::IfcMinuteInHour; case 2: return Type::IfcAheadOrBehind; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "HourOffset"; case 1: return "MinuteOffset"; case 2: return "Sense"; } 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_ENUMERATION; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcHourInDay; case 1: return Type::IfcMinuteInHour; case 2: return Type::IfcAheadOrBehind; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "HourOffset"; case 1: return "MinuteOffset"; case 2: return "Sense"; } 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; @@ -7719,9 +7719,9 @@ public: IfcLibraryInformation* RateSource() const; void setRateSource(IfcLibraryInformation* v); virtual unsigned int getArgumentCount() const { return 5; } - 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_DOUBLE; 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::IfcMonetaryUnit; case 1: return Type::IfcMonetaryUnit; case 2: return Type::IfcPositiveRatioMeasure; case 3: return Type::IfcDateAndTime; case 4: return Type::IfcLibraryInformation; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelatingMonetaryUnit"; case 1: return "RelatedMonetaryUnit"; case 2: return "ExchangeRate"; case 3: return "RateDateTime"; case 4: return "RateSource"; } 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_DOUBLE; 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::IfcMonetaryUnit; case 1: return Type::IfcMonetaryUnit; case 2: return Type::IfcPositiveRatioMeasure; case 3: return Type::IfcDateAndTime; case 4: return Type::IfcLibraryInformation; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelatingMonetaryUnit"; case 1: return "RelatedMonetaryUnit"; case 2: return "ExchangeRate"; case 3: return "RateDateTime"; case 4: return "RateSource"; } 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; @@ -7746,9 +7746,9 @@ public: IfcTemplatedEntityList< IfcCurveStyleFontPattern >::ptr PatternList() const; void setPatternList(IfcTemplatedEntityList< IfcCurveStyleFontPattern >::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::IfcLabel; case 1: return Type::IfcCurveStyleFontPattern; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "PatternList"; } 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::IfcLabel; case 1: return Type::IfcCurveStyleFontPattern; } 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 "PatternList"; } 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; @@ -7782,9 +7782,9 @@ public: double CurveFontScaling() const; void setCurveFontScaling(double 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_DOUBLE; } 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::IfcCurveStyleFontSelect; case 2: return Type::IfcPositiveRatioMeasure; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "CurveFont"; case 2: return "CurveFontScaling"; } 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_DOUBLE; } 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::IfcCurveStyleFontSelect; case 2: return Type::IfcPositiveRatioMeasure; } 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 "CurveFont"; case 2: return "CurveFontScaling"; } 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; @@ -7811,9 +7811,9 @@ public: double InvisibleSegmentLength() const; void setInvisibleSegmentLength(double v); virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcException("argument out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLengthMeasure; case 1: return Type::IfcPositiveLengthMeasure; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "VisibleSegmentLength"; case 1: return "InvisibleSegmentLength"; } 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_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLengthMeasure; case 1: return Type::IfcPositiveLengthMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "VisibleSegmentLength"; case 1: return "InvisibleSegmentLength"; } 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; @@ -7830,9 +7830,9 @@ public: IfcLocalTime* TimeComponent() const; void setTimeComponent(IfcLocalTime* 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::IfcCalendarDate; case 1: return Type::IfcLocalTime; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DateComponent"; case 1: return "TimeComponent"; } 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::IfcCalendarDate; case 1: return Type::IfcLocalTime; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DateComponent"; case 1: return "TimeComponent"; } 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; @@ -7861,9 +7861,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; @@ -7890,9 +7890,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; @@ -7942,9 +7942,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; @@ -7974,9 +7974,9 @@ public: std::string MimeSubtype() const; void setMimeSubtype(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::IfcLabel; case 1: return Type::IfcLabel; 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 "FileExtension"; case 1: return "MimeContentType"; case 2: return "MimeSubtype"; } 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::IfcLabel; case 1: return Type::IfcLabel; 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 "FileExtension"; case 1: return "MimeContentType"; case 2: return "MimeSubtype"; } 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; @@ -8083,9 +8083,9 @@ public: IfcDocumentStatusEnum::IfcDocumentStatusEnum Status() const; void setStatus(IfcDocumentStatusEnum::IfcDocumentStatusEnum v); virtual unsigned int getArgumentCount() const { return 17; } - 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_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_ENTITY_INSTANCE; case 11: return IfcUtil::Argument_ENTITY_INSTANCE; case 12: return IfcUtil::Argument_ENTITY_INSTANCE; case 13: return IfcUtil::Argument_ENTITY_INSTANCE; case 14: return IfcUtil::Argument_ENTITY_INSTANCE; case 15: return IfcUtil::Argument_ENUMERATION; case 16: 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::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcDocumentReference; case 4: return Type::IfcText; case 5: return Type::IfcText; case 6: return Type::IfcText; case 7: return Type::IfcLabel; case 8: return Type::IfcActorSelect; case 9: return Type::IfcActorSelect; case 10: return Type::IfcDateAndTime; case 11: return Type::IfcDateAndTime; case 12: return Type::IfcDocumentElectronicFormat; case 13: return Type::IfcCalendarDate; case 14: return Type::IfcCalendarDate; case 15: return Type::IfcDocumentConfidentialityEnum; case 16: return Type::IfcDocumentStatusEnum; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DocumentId"; case 1: return "Name"; case 2: return "Description"; case 3: return "DocumentReferences"; case 4: return "Purpose"; case 5: return "IntendedUse"; case 6: return "Scope"; case 7: return "Revision"; case 8: return "DocumentOwner"; case 9: return "Editors"; case 10: return "CreationTime"; case 11: return "LastRevisionTime"; case 12: return "ElectronicFormat"; case 13: return "ValidFrom"; case 14: return "ValidUntil"; case 15: return "Confidentiality"; case 16: return "Status"; } 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_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_ENTITY_INSTANCE; case 11: return IfcUtil::Argument_ENTITY_INSTANCE; case 12: return IfcUtil::Argument_ENTITY_INSTANCE; case 13: return IfcUtil::Argument_ENTITY_INSTANCE; case 14: return IfcUtil::Argument_ENTITY_INSTANCE; case 15: return IfcUtil::Argument_ENUMERATION; case 16: 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::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcDocumentReference; case 4: return Type::IfcText; case 5: return Type::IfcText; case 6: return Type::IfcText; case 7: return Type::IfcLabel; case 8: return Type::IfcActorSelect; case 9: return Type::IfcActorSelect; case 10: return Type::IfcDateAndTime; case 11: return Type::IfcDateAndTime; case 12: return Type::IfcDocumentElectronicFormat; case 13: return Type::IfcCalendarDate; case 14: return Type::IfcCalendarDate; case 15: return Type::IfcDocumentConfidentialityEnum; case 16: return Type::IfcDocumentStatusEnum; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DocumentId"; case 1: return "Name"; case 2: return "Description"; case 3: return "DocumentReferences"; case 4: return "Purpose"; case 5: return "IntendedUse"; case 6: return "Scope"; case 7: return "Revision"; case 8: return "DocumentOwner"; case 9: return "Editors"; case 10: return "CreationTime"; case 11: return "LastRevisionTime"; case 12: return "ElectronicFormat"; case 13: return "ValidFrom"; case 14: return "ValidUntil"; case 15: return "Confidentiality"; case 16: return "Status"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } IfcTemplatedEntityList< IfcDocumentInformationRelationship >::ptr IsPointedTo() const; // INVERSE IfcDocumentInformationRelationship::RelatedDocuments IfcTemplatedEntityList< IfcDocumentInformationRelationship >::ptr IsPointer() const; // INVERSE IfcDocumentInformationRelationship::RelatingDocument @@ -8118,9 +8118,9 @@ public: std::string RelationshipType() const; void setRelationshipType(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_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; 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::IfcDocumentInformation; case 1: return Type::IfcDocumentInformation; 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 "RelatingDocument"; case 1: return "RelatedDocuments"; case 2: return "RelationshipType"; } 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_AGGREGATE_OF_ENTITY_INSTANCE; 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::IfcDocumentInformation; case 1: return Type::IfcDocumentInformation; 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 "RelatingDocument"; case 1: return "RelatedDocuments"; case 2: return "RelationshipType"; } 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; @@ -8145,9 +8145,9 @@ public: IfcDraughtingCallout* RelatedDraughtingCallout() const; void setRelatedDraughtingCallout(IfcDraughtingCallout* 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_ENTITY_INSTANCE; case 3: 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::IfcDraughtingCallout; case 3: return Type::IfcDraughtingCallout; } 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 "RelatingDraughtingCallout"; case 3: return "RelatedDraughtingCallout"; } 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; } 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::IfcDraughtingCallout; case 3: return Type::IfcDraughtingCallout; } 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 "RelatingDraughtingCallout"; case 3: return "RelatedDraughtingCallout"; } 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; @@ -8207,9 +8207,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::IfcLabel; 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 "ItemReference"; 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::IfcLabel; 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 "ItemReference"; case 2: 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; @@ -8342,9 +8342,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 @@ -8369,9 +8369,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_ENTITY_INSTANCE; 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::IfcDateTimeSelect; 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_ENTITY_INSTANCE; 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::IfcDateTimeSelect; 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; @@ -8415,9 +8415,9 @@ public: IfcTemplatedEntityList< IfcLibraryReference >::ptr LibraryReference() const; void setLibraryReference(IfcTemplatedEntityList< IfcLibraryReference >::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_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_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::IfcLabel; case 1: return Type::IfcLabel; case 2: return Type::IfcOrganization; case 3: return Type::IfcCalendarDate; case 4: return Type::IfcLibraryReference; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Version"; case 2: return "Publisher"; case 3: return "VersionDate"; case 4: return "LibraryReference"; } 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_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::IfcLabel; case 2: return Type::IfcOrganization; case 3: return Type::IfcCalendarDate; case 4: return Type::IfcLibraryReference; } 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 "Version"; case 2: return "Publisher"; case 3: return "VersionDate"; case 4: return "LibraryReference"; } 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; @@ -8477,9 +8477,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; @@ -8500,9 +8500,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; @@ -8533,9 +8533,9 @@ public: int DaylightSavingOffset() const; void setDaylightSavingOffset(int v); virtual unsigned int getArgumentCount() const { return 5; } - 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_DOUBLE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: 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::IfcHourInDay; case 1: return Type::IfcMinuteInHour; case 2: return Type::IfcSecondInMinute; case 3: return Type::IfcCoordinatedUniversalTimeOffset; case 4: return Type::IfcDaylightSavingHour; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "HourComponent"; case 1: return "MinuteComponent"; case 2: return "SecondComponent"; case 3: return "Zone"; case 4: return "DaylightSavingOffset"; } 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_DOUBLE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: 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::IfcHourInDay; case 1: return Type::IfcMinuteInHour; case 2: return Type::IfcSecondInMinute; case 3: return Type::IfcCoordinatedUniversalTimeOffset; case 4: return Type::IfcDaylightSavingHour; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "HourComponent"; case 1: return "MinuteComponent"; case 2: return "SecondComponent"; case 3: return "Zone"; case 4: return "DaylightSavingOffset"; } 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; @@ -8581,9 +8581,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); } IfcTemplatedEntityList< IfcMaterialDefinitionRepresentation >::ptr HasRepresentation() const; // INVERSE IfcMaterialDefinitionRepresentation::RepresentedMaterial IfcTemplatedEntityList< IfcMaterialClassificationRelationship >::ptr ClassifiedAs() const; // INVERSE IfcMaterialClassificationRelationship::ClassifiedMaterial @@ -8608,9 +8608,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::IfcClassificationNotationSelect; 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::IfcClassificationNotationSelect; 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; @@ -8666,9 +8666,9 @@ public: bool IsVentilated() const; void setIsVentilated(bool 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_DOUBLE; 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::IfcMaterial; case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcLogical; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Material"; case 1: return "LayerThickness"; case 2: return "IsVentilated"; } 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_DOUBLE; 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::IfcMaterial; case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcLogical; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Material"; case 1: return "LayerThickness"; case 2: return "IsVentilated"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } IfcTemplatedEntityList< IfcMaterialLayerSet >::ptr ToMaterialLayerSet() const; // INVERSE IfcMaterialLayerSet::MaterialLayers bool is(Type::Enum v) const; @@ -8722,9 +8722,9 @@ public: std::string LayerSetName() const; void setLayerSetName(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_AGGREGATE_OF_ENTITY_INSTANCE; 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::IfcMaterialLayer; 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 "MaterialLayers"; case 1: return "LayerSetName"; } 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; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterialLayer; 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 "MaterialLayers"; case 1: return "LayerSetName"; } 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; @@ -8853,9 +8853,9 @@ public: double OffsetFromReferenceLine() const; void setOffsetFromReferenceLine(double 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_ENUMERATION; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcException("argument out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterialLayerSet; case 1: return Type::IfcLayerSetDirectionEnum; case 2: return Type::IfcDirectionSenseEnum; case 3: return Type::IfcLengthMeasure; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ForLayerSet"; case 1: return "LayerSetDirection"; case 2: return "DirectionSense"; case 3: return "OffsetFromReferenceLine"; } 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; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterialLayerSet; case 1: return Type::IfcLayerSetDirectionEnum; case 2: return Type::IfcDirectionSenseEnum; case 3: return Type::IfcLengthMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ForLayerSet"; case 1: return "LayerSetDirection"; case 2: return "DirectionSense"; case 3: return "OffsetFromReferenceLine"; } 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; @@ -8887,9 +8887,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; @@ -8928,9 +8928,9 @@ public: IfcMaterial* Material() const; void setMaterial(IfcMaterial* v); virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: 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::IfcMaterial; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Material"; } throw IfcParse::IfcException("argument out of range"); } + virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: 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::IfcMaterial; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Material"; } 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; @@ -8958,9 +8958,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; @@ -9135,9 +9135,9 @@ public: IfcCurrencyEnum::IfcCurrencyEnum Currency() const; void setCurrency(IfcCurrencyEnum::IfcCurrencyEnum v); virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: 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::IfcCurrencyEnum; } 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_ENUMERATION; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCurrencyEnum; } 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; @@ -9160,9 +9160,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; @@ -9185,9 +9185,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 @@ -9324,9 +9324,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 "Id"; 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 "Id"; 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 @@ -9361,9 +9361,9 @@ public: IfcTemplatedEntityList< IfcOrganization >::ptr RelatedOrganizations() const; void setRelatedOrganizations(IfcTemplatedEntityList< IfcOrganization >::ptr 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_ENTITY_INSTANCE; 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::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcOrganization; case 3: return Type::IfcOrganization; } 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 "RelatingOrganization"; case 3: return "RelatedOrganizations"; } 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_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::IfcOrganization; case 3: return Type::IfcOrganization; } 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 "RelatingOrganization"; case 3: return "RelatedOrganizations"; } 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; @@ -9417,9 +9417,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; @@ -9485,9 +9485,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 "Id"; 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 "Id"; 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; @@ -9516,9 +9516,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; @@ -9543,9 +9543,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< IfcPhysicalComplexQuantity >::ptr PartOfComplex() const; // INVERSE IfcPhysicalComplexQuantity::HasQuantities bool is(Type::Enum v) const; @@ -9654,9 +9654,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; @@ -9760,9 +9760,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; @@ -9827,9 +9827,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; @@ -9849,9 +9849,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; @@ -9893,9 +9893,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; @@ -10116,9 +10116,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); } bool is(Type::Enum v) const; Type::Enum type() const; @@ -10150,9 +10150,9 @@ public: IfcProfileDef* ProfileDefinition() const; void setProfileDefinition(IfcProfileDef* 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_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::IfcProfileDef; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ProfileName"; case 1: return "ProfileDefinition"; } 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; } 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::IfcProfileDef; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ProfileName"; case 1: return "ProfileDefinition"; } 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; @@ -10175,9 +10175,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::IfcIdentifier; 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::IfcIdentifier; 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< IfcPropertyDependencyRelationship >::ptr PropertyForDependance() const; // INVERSE IfcPropertyDependencyRelationship::DependingProperty IfcTemplatedEntityList< IfcPropertyDependencyRelationship >::ptr PropertyDependsOn() const; // INVERSE IfcPropertyDependencyRelationship::DependantProperty @@ -10205,9 +10205,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_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_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::IfcConstraint; case 1: return Type::IfcProperty; 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 "RelatingConstraint"; case 1: return "RelatedProperties"; 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_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_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::IfcConstraint; case 1: return Type::IfcProperty; 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 "RelatingConstraint"; case 1: return "RelatedProperties"; 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; @@ -10246,9 +10246,9 @@ public: std::string Expression() const; void setExpression(std::string v); virtual unsigned int getArgumentCount() const { return 5; } - 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_STRING; case 3: return IfcUtil::Argument_STRING; case 4: 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::IfcProperty; case 1: return Type::IfcProperty; case 2: return Type::IfcLabel; case 3: return Type::IfcText; case 4: return Type::IfcText; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DependingProperty"; case 1: return "DependantProperty"; case 2: return "Name"; case 3: return "Description"; case 4: return "Expression"; } 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_STRING; case 3: return IfcUtil::Argument_STRING; case 4: 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::IfcProperty; case 1: return Type::IfcProperty; case 2: return Type::IfcLabel; case 3: return Type::IfcText; case 4: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DependingProperty"; case 1: return "DependantProperty"; case 2: return "Name"; case 3: return "Description"; case 4: return "Expression"; } 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; @@ -10317,9 +10317,9 @@ public: IfcUnit* Unit() const; void setUnit(IfcUnit* 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_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::IfcValue; case 2: 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 "EnumerationValues"; case 2: 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_AGGREGATE_OF_ENTITY_INSTANCE; case 2: 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::IfcValue; case 2: 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 "EnumerationValues"; case 2: return "Unit"; } 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; @@ -10476,9 +10476,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_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_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::IfcDocumentSelect; case 1: return Type::IfcAppliedValue; 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 "ReferencedDocument"; case 1: return "ReferencingValues"; 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_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_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::IfcDocumentSelect; case 1: return Type::IfcAppliedValue; 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 "ReferencedDocument"; case 1: return "ReferencingValues"; 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; @@ -10521,9 +10521,9 @@ public: double BarCount() const; void setBarCount(double v); virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcException("argument out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAreaMeasure; case 1: return Type::IfcLabel; case 2: return Type::IfcReinforcingBarSurfaceEnum; case 3: return Type::IfcLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcCountMeasure; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TotalCrossSectionArea"; case 1: return "SteelGrade"; case 2: return "BarSurface"; case 3: return "EffectiveDepth"; case 4: return "NominalBarDiameter"; case 5: return "BarCount"; } 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_STRING; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAreaMeasure; case 1: return Type::IfcLabel; case 2: return Type::IfcReinforcingBarSurfaceEnum; case 3: return Type::IfcLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcCountMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TotalCrossSectionArea"; case 1: return "SteelGrade"; case 2: return "BarSurface"; case 3: return "EffectiveDepth"; case 4: return "NominalBarDiameter"; case 5: return "BarCount"; } 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; @@ -10540,9 +10540,9 @@ public: double InitialStress() const; void setInitialStress(double v); virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcException("argument out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcNormalisedRatioMeasure; case 1: return Type::IfcNormalisedRatioMeasure; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelaxationValue"; case 1: return "InitialStress"; } 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_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcNormalisedRatioMeasure; case 1: return Type::IfcNormalisedRatioMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelaxationValue"; case 1: return "InitialStress"; } 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; @@ -10617,9 +10617,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 @@ -10654,9 +10654,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; @@ -10701,9 +10701,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 LayerAssignments() const; // INVERSE IfcPresentationLayerAssignment::AssignedItems IfcTemplatedEntityList< IfcStyledItem >::ptr StyledByItem() const; // INVERSE IfcStyledItem::Item @@ -10735,9 +10735,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< IfcMappedItem >::ptr MapUsage() const; // INVERSE IfcMappedItem::MappingSource bool is(Type::Enum v) const; @@ -10812,9 +10812,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; @@ -10873,9 +10873,9 @@ public: IfcProfileDef* EndProfile() const; void setEndProfile(IfcProfileDef* 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_ENTITY_INSTANCE; case 2: 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::IfcSectionTypeEnum; case 1: return Type::IfcProfileDef; case 2: return Type::IfcProfileDef; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SectionType"; case 1: return "StartProfile"; case 2: return "EndProfile"; } 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_ENTITY_INSTANCE; case 2: 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::IfcSectionTypeEnum; case 1: return Type::IfcProfileDef; case 2: return Type::IfcProfileDef; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SectionType"; case 1: return "StartProfile"; case 2: return "EndProfile"; } 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; @@ -10914,9 +10914,9 @@ public: IfcTemplatedEntityList< IfcReinforcementBarProperties >::ptr CrossSectionReinforcementDefinitions() const; void setCrossSectionReinforcementDefinitions(IfcTemplatedEntityList< IfcReinforcementBarProperties >::ptr v); virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_ENUMERATION; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: 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::IfcLengthMeasure; case 1: return Type::IfcLengthMeasure; case 2: return Type::IfcLengthMeasure; case 3: return Type::IfcReinforcingBarRoleEnum; case 4: return Type::IfcSectionProperties; case 5: return Type::IfcReinforcementBarProperties; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LongitudinalStartPosition"; case 1: return "LongitudinalEndPosition"; case 2: return "TransversePosition"; case 3: return "ReinforcementRole"; case 4: return "SectionDefinition"; case 5: return "CrossSectionReinforcementDefinitions"; } 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_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_ENUMERATION; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: 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::IfcLengthMeasure; case 1: return Type::IfcLengthMeasure; case 2: return Type::IfcLengthMeasure; case 3: return Type::IfcReinforcingBarRoleEnum; case 4: return Type::IfcSectionProperties; case 5: return Type::IfcReinforcementBarProperties; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LongitudinalStartPosition"; case 1: return "LongitudinalEndPosition"; case 2: return "TransversePosition"; case 3: return "ReinforcementRole"; case 4: return "SectionDefinition"; case 5: return "CrossSectionReinforcementDefinitions"; } 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; @@ -10988,9 +10988,9 @@ public: IfcProductDefinitionShape* PartOfProductDefinitionShape() const; void setPartOfProductDefinitionShape(IfcProductDefinitionShape* 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::IfcProductDefinitionShape; } 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::IfcProductDefinitionShape; } 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; @@ -11209,9 +11209,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; @@ -11231,9 +11231,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; @@ -11449,9 +11449,9 @@ public: IfcColourRgb* ReflectanceColour() const; void setReflectanceColour(IfcColourRgb* 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_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: 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::IfcColourRgb; case 1: return Type::IfcColourRgb; case 2: return Type::IfcColourRgb; case 3: return Type::IfcColourRgb; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DiffuseTransmissionColour"; case 1: return "DiffuseReflectionColour"; case 2: return "TransmissionColour"; case 3: return "ReflectanceColour"; } 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_ENTITY_INSTANCE; case 3: 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::IfcColourRgb; case 1: return Type::IfcColourRgb; case 2: return Type::IfcColourRgb; case 3: return Type::IfcColourRgb; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DiffuseTransmissionColour"; case 1: return "DiffuseReflectionColour"; case 2: return "TransmissionColour"; case 3: return "ReflectanceColour"; } 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; @@ -11478,9 +11478,9 @@ public: double DispersionFactor() const; void setDispersionFactor(double v); virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcException("argument out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcReal; case 1: return Type::IfcReal; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RefractionIndex"; case 1: return "DispersionFactor"; } 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_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcReal; case 1: return Type::IfcReal; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RefractionIndex"; case 1: return "DispersionFactor"; } 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; @@ -11502,9 +11502,9 @@ public: IfcColourRgb* SurfaceColour() const; void setSurfaceColour(IfcColourRgb* v); virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: 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::IfcColourRgb; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SurfaceColour"; } throw IfcParse::IfcException("argument out of range"); } + virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: 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::IfcColourRgb; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SurfaceColour"; } 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; @@ -11537,9 +11537,9 @@ public: IfcTemplatedEntityList< IfcSurfaceTexture >::ptr Textures() const; void setTextures(IfcTemplatedEntityList< IfcSurfaceTexture >::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::IfcSurfaceTexture; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Textures"; } 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::IfcSurfaceTexture; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Textures"; } 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; @@ -11658,9 +11658,9 @@ public: IfcCartesianTransformationOperator2D* TextureTransform() const; void setTextureTransform(IfcCartesianTransformationOperator2D* v); virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_BOOL; case 1: return IfcUtil::Argument_BOOL; case 2: return IfcUtil::Argument_ENUMERATION; case 3: 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::UNDEFINED; case 1: return Type::UNDEFINED; case 2: return Type::IfcSurfaceTextureEnum; case 3: return Type::IfcCartesianTransformationOperator2D; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RepeatS"; case 1: return "RepeatT"; case 2: return "TextureType"; case 3: return "TextureTransform"; } throw IfcParse::IfcException("argument out of range"); } + virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_BOOL; case 1: return IfcUtil::Argument_BOOL; case 2: return IfcUtil::Argument_ENUMERATION; case 3: 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::UNDEFINED; case 1: return Type::UNDEFINED; case 2: return Type::IfcSurfaceTextureEnum; case 3: return Type::IfcCartesianTransformationOperator2D; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RepeatS"; case 1: return "RepeatT"; case 2: return "TextureType"; case 3: return "TextureTransform"; } 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; @@ -11715,9 +11715,9 @@ public: IfcTemplatedEntityList< IfcTableRow >::ptr Rows() const; void setRows(IfcTemplatedEntityList< IfcTableRow >::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::UNDEFINED; case 1: return Type::IfcTableRow; } 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"; } 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::UNDEFINED; case 1: return Type::IfcTableRow; } 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"; } 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; @@ -11748,9 +11748,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; @@ -12002,9 +12002,9 @@ public: IfcColour* BackgroundColour() const; void setBackgroundColour(IfcColour* 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::IfcColour; case 1: return Type::IfcColour; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Colour"; case 1: return "BackgroundColour"; } 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::IfcColour; case 1: return Type::IfcColour; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Colour"; case 1: return "BackgroundColour"; } 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; @@ -12065,9 +12065,9 @@ public: IfcSizeSelect* LineHeight() const; void setLineHeight(IfcSizeSelect* v); virtual unsigned int getArgumentCount() const { return 7; } - 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_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_STRING; case 6: 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::IfcSizeSelect; case 1: return Type::IfcTextAlignment; case 2: return Type::IfcTextDecoration; case 3: return Type::IfcSizeSelect; case 4: return Type::IfcSizeSelect; case 5: return Type::IfcTextTransformation; case 6: return Type::IfcSizeSelect; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TextIndent"; case 1: return "TextAlign"; case 2: return "TextDecoration"; case 3: return "LetterSpacing"; case 4: return "WordSpacing"; case 5: return "TextTransform"; case 6: return "LineHeight"; } 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_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_STRING; case 6: 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::IfcSizeSelect; case 1: return Type::IfcTextAlignment; case 2: return Type::IfcTextDecoration; case 3: return Type::IfcSizeSelect; case 4: return Type::IfcSizeSelect; case 5: return Type::IfcTextTransformation; case 6: return Type::IfcSizeSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TextIndent"; case 1: return "TextAlign"; case 2: return "TextDecoration"; case 3: return "LetterSpacing"; case 4: return "WordSpacing"; case 5: return "TextTransform"; case 6: return "LineHeight"; } 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; @@ -12121,9 +12121,9 @@ public: IfcSizeSelect* CharacterSpacing() const; void setCharacterSpacing(IfcSizeSelect* v); virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; 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::IfcPositiveLengthMeasure; case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcPlaneAngleMeasure; case 3: return Type::IfcPlaneAngleMeasure; case 4: return Type::IfcSizeSelect; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BoxHeight"; case 1: return "BoxWidth"; case 2: return "BoxSlantAngle"; case 3: return "BoxRotateAngle"; case 4: return "CharacterSpacing"; } 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_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; 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::IfcPositiveLengthMeasure; case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcPlaneAngleMeasure; case 3: return Type::IfcPlaneAngleMeasure; case 4: return Type::IfcSizeSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BoxHeight"; case 1: return "BoxWidth"; case 2: return "BoxSlantAngle"; case 3: return "BoxRotateAngle"; case 4: return "CharacterSpacing"; } 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; @@ -12146,9 +12146,9 @@ public: class IfcTextureCoordinate : 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< IfcAnnotationSurface >::ptr AnnotatedSurface() const; // INVERSE IfcAnnotationSurface::TextureCoordinates bool is(Type::Enum v) const; @@ -12308,9 +12308,9 @@ public: std::vector< double > /*[2:2]*/ Coordinates() const; void setCoordinates(std::vector< double > /*[2:2]*/ 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_DOUBLE; } throw IfcParse::IfcException("argument out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcParameterValue; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Coordinates"; } throw IfcParse::IfcException("argument out of range"); } + virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: 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::IfcParameterValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Coordinates"; } 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; @@ -12388,9 +12388,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_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; 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::IfcDateTimeSelect; case 3: return Type::IfcDateTimeSelect; 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_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; 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::IfcDateTimeSelect; case 3: return Type::IfcDateTimeSelect; 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< IfcTimeSeriesReferenceRelationship >::ptr DocumentedBy() const; // INVERSE IfcTimeSeriesReferenceRelationship::ReferencedTimeSeries bool is(Type::Enum v) const; @@ -12408,9 +12408,9 @@ public: IfcEntityList::ptr TimeSeriesReferences() const; void setTimeSeriesReferences(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_ENTITY_INSTANCE; 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::IfcTimeSeries; case 1: return Type::IfcDocumentSelect; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ReferencedTimeSeries"; case 1: return "TimeSeriesReferences"; } 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_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::IfcTimeSeries; case 1: return Type::IfcDocumentSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ReferencedTimeSeries"; case 1: return "TimeSeriesReferences"; } 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; @@ -12434,9 +12434,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; @@ -12523,9 +12523,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; @@ -12566,9 +12566,9 @@ public: IfcTemplatedEntityList< IfcCartesianPoint >::ptr TexturePoints() const; void setTexturePoints(IfcTemplatedEntityList< IfcCartesianPoint >::ptr 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_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcTextureVertex; case 1: return Type::IfcCartesianPoint; } throw IfcParse::IfcException("argument out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TextureVertices"; case 1: return "TexturePoints"; } 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_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcTextureVertex; case 1: return Type::IfcCartesianPoint; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } + virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TextureVertices"; case 1: return "TexturePoints"; } 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; @@ -12671,9 +12671,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; diff --git a/src/ifcparse/Ifc4.cpp b/src/ifcparse/Ifc4.cpp index fc6d0d862d..d599ac25b8 100644 --- a/src/ifcparse/Ifc4.cpp +++ b/src/ifcparse/Ifc4.cpp @@ -6510,7 +6510,7 @@ IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum IfcWorkScheduleTypeEnum::FromSt // 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; } @@ -6520,7 +6520,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; } @@ -6530,7 +6530,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; } @@ -6540,7 +6540,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; } @@ -6550,7 +6550,7 @@ IfcAngularVelocityMeasure::IfcAngularVelocityMeasure(double v) { IfcWritableEnti IfcAngularVelocityMeasure::operator double() const { return *entity->getArgument(0); } // Function implementations for IfcAreaDensityMeasure -IfcUtil::ArgumentType IfcAreaDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcAreaDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcAreaDensityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcAreaDensityMeasure::is(Type::Enum v) const { return v == IfcAreaDensityMeasure::Class(); } Type::Enum IfcAreaDensityMeasure::type() const { return Type::IfcAreaDensityMeasure; } @@ -6560,7 +6560,7 @@ IfcAreaDensityMeasure::IfcAreaDensityMeasure(double v) { IfcWritableEntity* e = IfcAreaDensityMeasure::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; } @@ -6570,7 +6570,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; } @@ -6580,7 +6580,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; } @@ -6590,7 +6590,7 @@ IfcBoxAlignment::IfcBoxAlignment(std::string v) : IfcLabel((IfcAbstractEntity*)0 IfcBoxAlignment::operator std::string() const { return *entity->getArgument(0); } // Function implementations for IfcCardinalPointReference -IfcUtil::ArgumentType IfcCardinalPointReference::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcCardinalPointReference::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcCardinalPointReference::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcCardinalPointReference::is(Type::Enum v) const { return v == IfcCardinalPointReference::Class(); } Type::Enum IfcCardinalPointReference::type() const { return Type::IfcCardinalPointReference; } @@ -6600,7 +6600,7 @@ IfcCardinalPointReference::IfcCardinalPointReference(int v) { IfcWritableEntity* IfcCardinalPointReference::operator int() 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; } @@ -6610,7 +6610,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; } @@ -6620,7 +6620,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; } @@ -6630,7 +6630,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; } @@ -6640,7 +6640,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; } @@ -6650,7 +6650,7 @@ IfcCurvatureMeasure::IfcCurvatureMeasure(double v) { IfcWritableEntity* e = new IfcCurvatureMeasure::operator double() const { return *entity->getArgument(0); } // Function implementations for IfcDate -IfcUtil::ArgumentType IfcDate::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcDate::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcDate::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcDate::is(Type::Enum v) const { return v == IfcDate::Class(); } Type::Enum IfcDate::type() const { return Type::IfcDate; } @@ -6660,7 +6660,7 @@ IfcDate::IfcDate(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(T IfcDate::operator std::string() const { return *entity->getArgument(0); } // Function implementations for IfcDateTime -IfcUtil::ArgumentType IfcDateTime::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcDateTime::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcDateTime::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcDateTime::is(Type::Enum v) const { return v == IfcDateTime::Class(); } Type::Enum IfcDateTime::type() const { return Type::IfcDateTime; } @@ -6670,7 +6670,7 @@ IfcDateTime::IfcDateTime(std::string v) { IfcWritableEntity* e = new IfcWritable IfcDateTime::operator std::string() 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; } @@ -6680,7 +6680,7 @@ IfcDayInMonthNumber::IfcDayInMonthNumber(int v) { IfcWritableEntity* e = new Ifc IfcDayInMonthNumber::operator int() const { return *entity->getArgument(0); } // Function implementations for IfcDayInWeekNumber -IfcUtil::ArgumentType IfcDayInWeekNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcDayInWeekNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcDayInWeekNumber::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcDayInWeekNumber::is(Type::Enum v) const { return v == IfcDayInWeekNumber::Class(); } Type::Enum IfcDayInWeekNumber::type() const { return Type::IfcDayInWeekNumber; } @@ -6690,7 +6690,7 @@ IfcDayInWeekNumber::IfcDayInWeekNumber(int v) { IfcWritableEntity* e = new IfcWr IfcDayInWeekNumber::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; } @@ -6700,7 +6700,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; } @@ -6710,7 +6710,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; } @@ -6720,7 +6720,7 @@ IfcDoseEquivalentMeasure::IfcDoseEquivalentMeasure(double v) { IfcWritableEntity IfcDoseEquivalentMeasure::operator double() const { return *entity->getArgument(0); } // Function implementations for IfcDuration -IfcUtil::ArgumentType IfcDuration::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcDuration::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcDuration::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcDuration::is(Type::Enum v) const { return v == IfcDuration::Class(); } Type::Enum IfcDuration::type() const { return Type::IfcDuration; } @@ -6730,7 +6730,7 @@ IfcDuration::IfcDuration(std::string v) { IfcWritableEntity* e = new IfcWritable IfcDuration::operator std::string() 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; } @@ -6740,7 +6740,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; } @@ -6750,7 +6750,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; } @@ -6760,7 +6760,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; } @@ -6770,7 +6770,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; } @@ -6780,7 +6780,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; } @@ -6790,7 +6790,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; } @@ -6800,7 +6800,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; } @@ -6810,7 +6810,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; } @@ -6820,7 +6820,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; } @@ -6830,7 +6830,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; } @@ -6840,7 +6840,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; } @@ -6850,7 +6850,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; } @@ -6860,7 +6860,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; } @@ -6870,7 +6870,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; } @@ -6880,7 +6880,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; } @@ -6890,7 +6890,7 @@ IfcHeatingValueMeasure::IfcHeatingValueMeasure(double v) { IfcWritableEntity* e IfcHeatingValueMeasure::operator double() 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; } @@ -6900,7 +6900,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; } @@ -6910,7 +6910,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; } @@ -6920,7 +6920,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; } @@ -6930,7 +6930,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; } @@ -6940,7 +6940,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; } @@ -6950,7 +6950,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; } @@ -6960,7 +6960,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; } @@ -6970,7 +6970,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; } @@ -6980,7 +6980,7 @@ IfcLabel::IfcLabel(std::string v) { IfcWritableEntity* e = new IfcWritableEntity IfcLabel::operator std::string() const { return *entity->getArgument(0); } // Function implementations for IfcLanguageId -IfcUtil::ArgumentType IfcLanguageId::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcLanguageId::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcLanguageId::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcLanguageId::is(Type::Enum v) const { return v == Type::IfcLanguageId || IfcIdentifier::is(v); } Type::Enum IfcLanguageId::type() const { return Type::IfcLanguageId; } @@ -6990,7 +6990,7 @@ IfcLanguageId::IfcLanguageId(std::string v) : IfcIdentifier((IfcAbstractEntity*) IfcLanguageId::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; } @@ -7000,7 +7000,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; } @@ -7010,7 +7010,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; } @@ -7020,7 +7020,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; } @@ -7030,7 +7030,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; } @@ -7040,7 +7040,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; } @@ -7050,7 +7050,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; } @@ -7060,7 +7060,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; } @@ -7070,7 +7070,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; } @@ -7080,7 +7080,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; } @@ -7090,7 +7090,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; } @@ -7100,7 +7100,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; } @@ -7110,7 +7110,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; } @@ -7120,7 +7120,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; } @@ -7130,7 +7130,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; } @@ -7140,7 +7140,7 @@ IfcMassPerLengthMeasure::IfcMassPerLengthMeasure(double v) { IfcWritableEntity* IfcMassPerLengthMeasure::operator double() 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; } @@ -7150,7 +7150,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; } @@ -7160,7 +7160,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; } @@ -7170,7 +7170,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; } @@ -7180,7 +7180,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; } @@ -7190,7 +7190,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; } @@ -7200,7 +7200,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; } @@ -7210,7 +7210,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; } @@ -7220,7 +7220,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; } @@ -7230,7 +7230,7 @@ IfcMonthInYearNumber::IfcMonthInYearNumber(int v) { IfcWritableEntity* e = new I IfcMonthInYearNumber::operator int() const { return *entity->getArgument(0); } // Function implementations for IfcNonNegativeLengthMeasure -IfcUtil::ArgumentType IfcNonNegativeLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcNonNegativeLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcNonNegativeLengthMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcNonNegativeLengthMeasure::is(Type::Enum v) const { return v == Type::IfcNonNegativeLengthMeasure || IfcLengthMeasure::is(v); } Type::Enum IfcNonNegativeLengthMeasure::type() const { return Type::IfcNonNegativeLengthMeasure; } @@ -7240,7 +7240,7 @@ IfcNonNegativeLengthMeasure::IfcNonNegativeLengthMeasure(double v) : IfcLengthMe IfcNonNegativeLengthMeasure::operator double() 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; } @@ -7250,7 +7250,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; } @@ -7260,7 +7260,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; } @@ -7270,7 +7270,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; } @@ -7280,7 +7280,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; } @@ -7290,7 +7290,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; } @@ -7300,7 +7300,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; } @@ -7310,7 +7310,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; } @@ -7320,7 +7320,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; } @@ -7330,7 +7330,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; } @@ -7340,7 +7340,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; } @@ -7350,7 +7350,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; } @@ -7360,7 +7360,7 @@ IfcPressureMeasure::IfcPressureMeasure(double v) { IfcWritableEntity* e = new If IfcPressureMeasure::operator double() const { return *entity->getArgument(0); } // Function implementations for IfcPropertySetDefinitionSet -IfcUtil::ArgumentType IfcPropertySetDefinitionSet::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_ENTITY_INSTANCE; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcPropertySetDefinitionSet::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_ENTITY_INSTANCE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcPropertySetDefinitionSet::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcPropertySetDefinitionSet::is(Type::Enum v) const { return v == IfcPropertySetDefinitionSet::Class(); } Type::Enum IfcPropertySetDefinitionSet::type() const { return Type::IfcPropertySetDefinitionSet; } @@ -7370,7 +7370,7 @@ IfcPropertySetDefinitionSet::IfcPropertySetDefinitionSet(IfcTemplatedEntityList< IfcPropertySetDefinitionSet::operator IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } // 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; } @@ -7380,7 +7380,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; } @@ -7390,7 +7390,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; } @@ -7400,7 +7400,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; } @@ -7410,7 +7410,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; } @@ -7420,7 +7420,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; } @@ -7430,7 +7430,7 @@ IfcRotationalStiffnessMeasure::IfcRotationalStiffnessMeasure(double v) { IfcWrit IfcRotationalStiffnessMeasure::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; } @@ -7440,7 +7440,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; } @@ -7450,7 +7450,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; } @@ -7460,7 +7460,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; } @@ -7470,7 +7470,7 @@ IfcSolidAngleMeasure::IfcSolidAngleMeasure(double v) { IfcWritableEntity* e = ne IfcSolidAngleMeasure::operator double() const { return *entity->getArgument(0); } // Function implementations for IfcSoundPowerLevelMeasure -IfcUtil::ArgumentType IfcSoundPowerLevelMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcSoundPowerLevelMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcSoundPowerLevelMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcSoundPowerLevelMeasure::is(Type::Enum v) const { return v == IfcSoundPowerLevelMeasure::Class(); } Type::Enum IfcSoundPowerLevelMeasure::type() const { return Type::IfcSoundPowerLevelMeasure; } @@ -7480,7 +7480,7 @@ IfcSoundPowerLevelMeasure::IfcSoundPowerLevelMeasure(double v) { IfcWritableEnti IfcSoundPowerLevelMeasure::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; } @@ -7490,7 +7490,7 @@ IfcSoundPowerMeasure::IfcSoundPowerMeasure(double v) { IfcWritableEntity* e = ne IfcSoundPowerMeasure::operator double() const { return *entity->getArgument(0); } // Function implementations for IfcSoundPressureLevelMeasure -IfcUtil::ArgumentType IfcSoundPressureLevelMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcSoundPressureLevelMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcSoundPressureLevelMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcSoundPressureLevelMeasure::is(Type::Enum v) const { return v == IfcSoundPressureLevelMeasure::Class(); } Type::Enum IfcSoundPressureLevelMeasure::type() const { return Type::IfcSoundPressureLevelMeasure; } @@ -7500,7 +7500,7 @@ IfcSoundPressureLevelMeasure::IfcSoundPressureLevelMeasure(double v) { IfcWritab IfcSoundPressureLevelMeasure::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; } @@ -7510,7 +7510,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; } @@ -7520,7 +7520,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; } @@ -7530,7 +7530,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; } @@ -7540,7 +7540,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; } @@ -7550,7 +7550,7 @@ IfcTemperatureGradientMeasure::IfcTemperatureGradientMeasure(double v) { IfcWrit IfcTemperatureGradientMeasure::operator double() const { return *entity->getArgument(0); } // Function implementations for IfcTemperatureRateOfChangeMeasure -IfcUtil::ArgumentType IfcTemperatureRateOfChangeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcTemperatureRateOfChangeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcTemperatureRateOfChangeMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcTemperatureRateOfChangeMeasure::is(Type::Enum v) const { return v == IfcTemperatureRateOfChangeMeasure::Class(); } Type::Enum IfcTemperatureRateOfChangeMeasure::type() const { return Type::IfcTemperatureRateOfChangeMeasure; } @@ -7560,7 +7560,7 @@ IfcTemperatureRateOfChangeMeasure::IfcTemperatureRateOfChangeMeasure(double v) { IfcTemperatureRateOfChangeMeasure::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; } @@ -7570,7 +7570,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; } @@ -7580,7 +7580,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; } @@ -7590,7 +7590,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; } @@ -7600,7 +7600,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; } @@ -7610,7 +7610,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; } @@ -7620,7 +7620,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; } @@ -7630,7 +7630,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; } @@ -7640,7 +7640,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; } @@ -7650,7 +7650,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; } @@ -7660,7 +7660,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; } @@ -7670,7 +7670,7 @@ IfcThermodynamicTemperatureMeasure::IfcThermodynamicTemperatureMeasure(double v) IfcThermodynamicTemperatureMeasure::operator double() const { return *entity->getArgument(0); } // Function implementations for IfcTime -IfcUtil::ArgumentType IfcTime::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcTime::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcTime::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcTime::is(Type::Enum v) const { return v == IfcTime::Class(); } Type::Enum IfcTime::type() const { return Type::IfcTime; } @@ -7680,7 +7680,7 @@ IfcTime::IfcTime(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(T IfcTime::operator std::string() 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; } @@ -7690,7 +7690,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; } @@ -7700,7 +7700,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; } @@ -7710,7 +7710,7 @@ IfcTorqueMeasure::IfcTorqueMeasure(double v) { IfcWritableEntity* e = new IfcWri IfcTorqueMeasure::operator double() const { return *entity->getArgument(0); } // Function implementations for IfcURIReference -IfcUtil::ArgumentType IfcURIReference::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } } +IfcUtil::ArgumentType IfcURIReference::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } Argument* IfcURIReference::getArgument(unsigned int i) const { return entity->getArgument(i); } bool IfcURIReference::is(Type::Enum v) const { return v == IfcURIReference::Class(); } Type::Enum IfcURIReference::type() const { return Type::IfcURIReference; } @@ -7720,7 +7720,7 @@ IfcURIReference::IfcURIReference(std::string v) { IfcWritableEntity* e = new Ifc IfcURIReference::operator std::string() 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; } @@ -7730,7 +7730,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; } @@ -7740,7 +7740,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; } @@ -7750,7 +7750,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; } @@ -7760,7 +7760,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; } diff --git a/src/ifcparse/Ifc4.h b/src/ifcparse/Ifc4.h index 6852b1c566..4f01c4f55c 100644 --- a/src/ifcparse/Ifc4.h +++ b/src/ifcparse/Ifc4.h @@ -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; diff --git a/src/ifcparse/IfcEntityDescriptor.h b/src/ifcparse/IfcEntityDescriptor.h index e90e5b5959..588a90337e 100644 --- a/src/ifcparse/IfcEntityDescriptor.h +++ b/src/ifcparse/IfcEntityDescriptor.h @@ -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) diff --git a/src/ifcparse/IfcException.h b/src/ifcparse/IfcException.h index 2bdc9875ca..f0a5320409 100644 --- a/src/ifcparse/IfcException.h +++ b/src/ifcparse/IfcException.h @@ -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 () {} }; } diff --git a/src/ifcparse/IfcParse.cpp b/src/ifcparse/IfcParse.cpp index b2c8f7b15c..593a512a1b 100644 --- a/src/ifcparse/IfcParse.cpp +++ b/src/ifcparse/IfcParse.cpp @@ -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 ) { diff --git a/src/ifcparse/IfcUtil.cpp b/src/ifcparse/IfcUtil.cpp index f2a2d958b9..d9f3e4ef81 100644 --- a/src/ifcparse/IfcUtil.cpp +++ b/src/ifcparse/IfcUtil.cpp @@ -71,7 +71,7 @@ IfcEntityList::ptr IfcEntityList::filtered(const std::set 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;