From 9b36321861857391ac8bc70df3ed82bef6038107 Mon Sep 17 00:00:00 2001 From: Thomas Krijnen Date: Mon, 25 Jul 2011 14:56:40 +0000 Subject: [PATCH] Rewritten library to use code generated from IFC2X3_TC1.exp --- cmake/CMakeLists.txt | 16 +- src/ifcobj/IfcObj.cpp | 19 +- src/ifcparse/Ifc2x3.cpp | 9482 ++++++++++++++++++++++++ src/ifcparse/Ifc2x3.h | 9289 +++++++++++++++++++++++ src/ifcparse/Ifc2x3enum.h | 42 + src/ifcparse/IfcGeom.h | 91 +- src/ifcparse/IfcGeomCurves.cpp | 116 + src/ifcparse/IfcGeomFaces.cpp | 266 + src/ifcparse/IfcGeomFunctions.cpp | 142 + src/ifcparse/IfcGeomHelpers.cpp | 211 + src/ifcparse/IfcGeomObjects.cpp | 107 +- src/ifcparse/IfcGeomObjects.h | 2 +- src/ifcparse/IfcGeomShapes.cpp | 231 + src/ifcparse/IfcGeomWires.cpp | 176 + src/ifcparse/IfcParse.cpp | 307 +- src/ifcparse/IfcParse.h | 133 +- src/ifcparse/IfcRegister.cpp | 56 + src/ifcparse/IfcRegister.h | 80 + src/ifcparse/IfcRegisterConvertCurve.h | 6 + src/ifcparse/IfcRegisterConvertFace.h | 6 + src/ifcparse/IfcRegisterConvertShape.h | 14 + src/ifcparse/IfcRegisterConvertWire.h | 6 + src/ifcparse/IfcRegisterCreateCache.h | 6 + src/ifcparse/IfcRegisterDef.h | 15 + src/ifcparse/IfcRegisterGeomHeader.h | 9 + src/ifcparse/IfcRegisterPurgeCache.h | 6 + src/ifcparse/IfcRegisterUndef.h | 15 + src/ifcparse/IfcUtil.cpp | 61 + src/ifcparse/IfcUtil.h | 145 + src/ifcparse/SharedPointer.h | 38 + 30 files changed, 20753 insertions(+), 340 deletions(-) create mode 100644 src/ifcparse/Ifc2x3.cpp create mode 100644 src/ifcparse/Ifc2x3.h create mode 100644 src/ifcparse/Ifc2x3enum.h create mode 100644 src/ifcparse/IfcGeomCurves.cpp create mode 100644 src/ifcparse/IfcGeomFaces.cpp create mode 100644 src/ifcparse/IfcGeomFunctions.cpp create mode 100644 src/ifcparse/IfcGeomHelpers.cpp create mode 100644 src/ifcparse/IfcGeomShapes.cpp create mode 100644 src/ifcparse/IfcGeomWires.cpp create mode 100644 src/ifcparse/IfcRegister.cpp create mode 100644 src/ifcparse/IfcRegister.h create mode 100644 src/ifcparse/IfcRegisterConvertCurve.h create mode 100644 src/ifcparse/IfcRegisterConvertFace.h create mode 100644 src/ifcparse/IfcRegisterConvertShape.h create mode 100644 src/ifcparse/IfcRegisterConvertWire.h create mode 100644 src/ifcparse/IfcRegisterCreateCache.h create mode 100644 src/ifcparse/IfcRegisterDef.h create mode 100644 src/ifcparse/IfcRegisterGeomHeader.h create mode 100644 src/ifcparse/IfcRegisterPurgeCache.h create mode 100644 src/ifcparse/IfcRegisterUndef.h create mode 100644 src/ifcparse/IfcUtil.cpp create mode 100644 src/ifcparse/IfcUtil.h create mode 100644 src/ifcparse/SharedPointer.h diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt index abe893e5f5..10511ac2c6 100644 --- a/cmake/CMakeLists.txt +++ b/cmake/CMakeLists.txt @@ -58,11 +58,23 @@ CHECK_ADD_OCE_OCC_DEF(iomanip.h) CHECK_ADD_OCE_OCC_DEF(iostream) CHECK_ADD_OCE_OCC_DEF(iostream.h) -ADD_DEFINITIONS(-O3) +ADD_DEFINITIONS(-O2) ADD_DEFINITIONS(-fPIC) INCLUDE_DIRECTORIES(${OCC_INCLUDE_DIR}) -ADD_LIBRARY(IfcParse STATIC ../src/ifcparse/IfcEnum.cpp ../src/ifcparse/IfcTypes.cpp ../src/ifcparse/IfcParse.cpp ../src/ifcparse/IfcGeom.cpp ../src/ifcparse/IfcGeomObjects.cpp) +ADD_LIBRARY(IfcParse STATIC + ../src/ifcparse/IfcGeomWires.cpp + ../src/ifcparse/Ifc2x3.cpp + ../src/ifcparse/IfcGeomHelpers.cpp + ../src/ifcparse/IfcGeomFunctions.cpp + ../src/ifcparse/IfcGeomObjects.cpp + ../src/ifcparse/IfcGeomShapes.cpp + ../src/ifcparse/IfcGeomFaces.cpp + ../src/ifcparse/IfcRegister.cpp + ../src/ifcparse/IfcUtil.cpp + ../src/ifcparse/IfcGeomCurves.cpp + ../src/ifcparse/IfcParse.cpp +) LINK_DIRECTORIES (${IfcOpenShell_BINARY_DIR} /usr/lib) ADD_EXECUTABLE(IfcObj ../src/ifcobj/IfcObj.cpp) diff --git a/src/ifcobj/IfcObj.cpp b/src/ifcobj/IfcObj.cpp index 5d2845c92c..c6b94efe20 100644 --- a/src/ifcobj/IfcObj.cpp +++ b/src/ifcobj/IfcObj.cpp @@ -26,6 +26,7 @@ ********************************************************************************/ #include +#include #include #include @@ -46,9 +47,12 @@ int main ( int argc, char** argv ) { return 1; } + // Stream for log messages, we don't want to interupt our new progress bar... + std::stringstream ss; + // Parse the file supplied in argv[1]. Returns true on succes. // The second argument defines whether geometry will be defined using global or local coordinates. - if ( ! IfcGeomObjects::Init(argv[1],true) ) { + if ( ! IfcGeomObjects::Init(argv[1],true,&ss) ) { std::cout << "[Error] unable to parse .ifc file or no geometrical entities found" << std::endl; return 1; } @@ -59,6 +63,8 @@ int main ( int argc, char** argv ) { time_t start,end; time(&start); + int old_progress = -1; + std::cout << "Creating geometry..." << std::endl; // The functions IfcGeomObjects::Get() and IfcGeomObjects::Next() wrap an iterator of all geometrical entities in the Ifc file. // IfcGeomObjects::Get() returns an IfcGeomObjects::IfcGeomObject (see IfcObjects.h for definition) @@ -82,7 +88,13 @@ int main ( int argc, char** argv ) { const int v3 = *(it++)-vcount; fObj << "f " << v1 << " " << v2 << " " << v3 << std::endl; } + + const int progress = IfcGeomObjects::Progress() / 2; + if ( old_progress!= progress ) std::cout << "\r[" << std::string(progress,'#') << std::string(50 - progress,' ') << "]" << std::flush; + old_progress = progress; + } while ( IfcGeomObjects::Next() ); + std::cout << "\rDone creating geometry " << std::endl; // Writes the material settings, defined in Materials.h fMtl << "# File generated by IfcOpenShell" << std::endl; @@ -90,7 +102,10 @@ int main ( int argc, char** argv ) { fMtl << GetMaterial(*it); } + std::cout << std::endl << "Log:" << std::endl; + std::cout << ss.str(); + time(&end); int dif = (int) difftime (end,start); - printf ("Conversion took %d seconds\n", dif ); + printf ("\nConversion took %d seconds\n", dif ); } diff --git a/src/ifcparse/Ifc2x3.cpp b/src/ifcparse/Ifc2x3.cpp new file mode 100644 index 0000000000..6066981b65 --- /dev/null +++ b/src/ifcparse/Ifc2x3.cpp @@ -0,0 +1,9482 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +/******************************************************************************** + * * + * This file has been generated from IFC2X3_TC1.exp. Do not make modifications * + * but instead modify the python script that has been used to generate this. * + * * + ********************************************************************************/ + +#include "Ifc2x3.h" + +using namespace Ifc2x3; + +IfcSchemaEntity Ifc2x3::SchemaEntity(IfcAbstractEntityPtr e) { + if ( e->is(Type::IfcSoundPowerMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcRotationalFrequencyMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSpecificHeatCapacityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricConductanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricChargeMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPositiveLengthMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcAngularVelocityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcNullStyle) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcIonConcentrationMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcModulusOfLinearSubgradeReactionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcHeatFluxDensityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcHeatingValueMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcForceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPositiveRatioMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMolecularWeightMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLuminousFluxMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcNormalisedRatioMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLabel) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcTimeStamp) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcNumericMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcRotationalMassMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLinearForceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcKinematicViscosityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMassDensityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcIntegerCountRateMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcRadioActivityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcReal) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLinearMomentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricCurrentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermalTransmittanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcModulusOfElasticityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcInductanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcWarpingMomentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcDynamicViscosityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcAreaMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLogical) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcAmountOfSubstanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcContextDependentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermalConductivityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcEnergyMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcRotationalStiffnessMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcDerivedMeasureValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPowerMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermalExpansionCoefficientMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcTorqueMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMassPerLengthMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcCountMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcCurveStyleFontSelect) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcVolumetricFlowRateMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcModulusOfSubgradeReactionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMassFlowRateMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMonetaryMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcTemperatureGradientMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcColour) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcVolumeMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSectionalAreaIntegralMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcVaporPermeabilityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLinearVelocityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLengthMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcModulusOfRotationalSubgradeReactionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPlanarForceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcInteger) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSimpleValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMeasureValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPlaneAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcWarpingConstantMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricCapacitanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSoundPressureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSpecularRoughness) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcIlluminanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcText) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcTimeMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcAccelerationMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLuminousIntensityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPressureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricVoltageMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermodynamicTemperatureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMagneticFluxMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSolidAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcFrequencyMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPHMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermalAdmittanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSpecularExponent) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcDateTimeSelect) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLinearStiffnessMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcCompoundPlaneAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcCurvatureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcAbsorbedDoseMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcParameterValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcDescriptiveMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMomentOfInertiaMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcDoseEquivalentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcComplexNumber) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcRatioMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLuminousIntensityDistributionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcIsothermalMoistureCapacityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricResistanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermalResistanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcShearModulusMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcIdentifier) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcBoolean) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSectionModulusMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMassMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMoistureDiffusivityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPositivePlaneAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMagneticFluxDensityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::Ifc2DCompositeCurve) ) return IfcSchemaEntity(new Ifc2DCompositeCurve(e)); + if ( e->is(Type::IfcActionRequest) ) return IfcSchemaEntity(new IfcActionRequest(e)); + if ( e->is(Type::IfcActor) ) return IfcSchemaEntity(new IfcActor(e)); + if ( e->is(Type::IfcActorRole) ) return IfcSchemaEntity(new IfcActorRole(e)); + if ( e->is(Type::IfcActuatorType) ) return IfcSchemaEntity(new IfcActuatorType(e)); + if ( e->is(Type::IfcAddress) ) return IfcSchemaEntity(new IfcAddress(e)); + if ( e->is(Type::IfcAirTerminalBoxType) ) return IfcSchemaEntity(new IfcAirTerminalBoxType(e)); + if ( e->is(Type::IfcAirTerminalType) ) return IfcSchemaEntity(new IfcAirTerminalType(e)); + if ( e->is(Type::IfcAirToAirHeatRecoveryType) ) return IfcSchemaEntity(new IfcAirToAirHeatRecoveryType(e)); + if ( e->is(Type::IfcAlarmType) ) return IfcSchemaEntity(new IfcAlarmType(e)); + if ( e->is(Type::IfcAngularDimension) ) return IfcSchemaEntity(new IfcAngularDimension(e)); + if ( e->is(Type::IfcAnnotation) ) return IfcSchemaEntity(new IfcAnnotation(e)); + if ( e->is(Type::IfcAnnotationCurveOccurrence) ) return IfcSchemaEntity(new IfcAnnotationCurveOccurrence(e)); + if ( e->is(Type::IfcAnnotationFillArea) ) return IfcSchemaEntity(new IfcAnnotationFillArea(e)); + if ( e->is(Type::IfcAnnotationFillAreaOccurrence) ) return IfcSchemaEntity(new IfcAnnotationFillAreaOccurrence(e)); + if ( e->is(Type::IfcAnnotationOccurrence) ) return IfcSchemaEntity(new IfcAnnotationOccurrence(e)); + if ( e->is(Type::IfcAnnotationSurface) ) return IfcSchemaEntity(new IfcAnnotationSurface(e)); + if ( e->is(Type::IfcAnnotationSurfaceOccurrence) ) return IfcSchemaEntity(new IfcAnnotationSurfaceOccurrence(e)); + if ( e->is(Type::IfcAnnotationSymbolOccurrence) ) return IfcSchemaEntity(new IfcAnnotationSymbolOccurrence(e)); + if ( e->is(Type::IfcAnnotationTextOccurrence) ) return IfcSchemaEntity(new IfcAnnotationTextOccurrence(e)); + if ( e->is(Type::IfcApplication) ) return IfcSchemaEntity(new IfcApplication(e)); + if ( e->is(Type::IfcAppliedValue) ) return IfcSchemaEntity(new IfcAppliedValue(e)); + if ( e->is(Type::IfcAppliedValueRelationship) ) return IfcSchemaEntity(new IfcAppliedValueRelationship(e)); + if ( e->is(Type::IfcApproval) ) return IfcSchemaEntity(new IfcApproval(e)); + if ( e->is(Type::IfcApprovalActorRelationship) ) return IfcSchemaEntity(new IfcApprovalActorRelationship(e)); + if ( e->is(Type::IfcApprovalPropertyRelationship) ) return IfcSchemaEntity(new IfcApprovalPropertyRelationship(e)); + if ( e->is(Type::IfcApprovalRelationship) ) return IfcSchemaEntity(new IfcApprovalRelationship(e)); + if ( e->is(Type::IfcArbitraryClosedProfileDef) ) return IfcSchemaEntity(new IfcArbitraryClosedProfileDef(e)); + if ( e->is(Type::IfcArbitraryOpenProfileDef) ) return IfcSchemaEntity(new IfcArbitraryOpenProfileDef(e)); + if ( e->is(Type::IfcArbitraryProfileDefWithVoids) ) return IfcSchemaEntity(new IfcArbitraryProfileDefWithVoids(e)); + if ( e->is(Type::IfcAsset) ) return IfcSchemaEntity(new IfcAsset(e)); + if ( e->is(Type::IfcAsymmetricIShapeProfileDef) ) return IfcSchemaEntity(new IfcAsymmetricIShapeProfileDef(e)); + if ( e->is(Type::IfcAxis1Placement) ) return IfcSchemaEntity(new IfcAxis1Placement(e)); + if ( e->is(Type::IfcAxis2Placement2D) ) return IfcSchemaEntity(new IfcAxis2Placement2D(e)); + if ( e->is(Type::IfcAxis2Placement3D) ) return IfcSchemaEntity(new IfcAxis2Placement3D(e)); + if ( e->is(Type::IfcBSplineCurve) ) return IfcSchemaEntity(new IfcBSplineCurve(e)); + if ( e->is(Type::IfcBeam) ) return IfcSchemaEntity(new IfcBeam(e)); + if ( e->is(Type::IfcBeamType) ) return IfcSchemaEntity(new IfcBeamType(e)); + if ( e->is(Type::IfcBezierCurve) ) return IfcSchemaEntity(new IfcBezierCurve(e)); + if ( e->is(Type::IfcBlobTexture) ) return IfcSchemaEntity(new IfcBlobTexture(e)); + if ( e->is(Type::IfcBlock) ) return IfcSchemaEntity(new IfcBlock(e)); + if ( e->is(Type::IfcBoilerType) ) return IfcSchemaEntity(new IfcBoilerType(e)); + if ( e->is(Type::IfcBooleanClippingResult) ) return IfcSchemaEntity(new IfcBooleanClippingResult(e)); + if ( e->is(Type::IfcBooleanResult) ) return IfcSchemaEntity(new IfcBooleanResult(e)); + if ( e->is(Type::IfcBoundaryCondition) ) return IfcSchemaEntity(new IfcBoundaryCondition(e)); + if ( e->is(Type::IfcBoundaryEdgeCondition) ) return IfcSchemaEntity(new IfcBoundaryEdgeCondition(e)); + if ( e->is(Type::IfcBoundaryFaceCondition) ) return IfcSchemaEntity(new IfcBoundaryFaceCondition(e)); + if ( e->is(Type::IfcBoundaryNodeCondition) ) return IfcSchemaEntity(new IfcBoundaryNodeCondition(e)); + if ( e->is(Type::IfcBoundaryNodeConditionWarping) ) return IfcSchemaEntity(new IfcBoundaryNodeConditionWarping(e)); + if ( e->is(Type::IfcBoundedCurve) ) return IfcSchemaEntity(new IfcBoundedCurve(e)); + if ( e->is(Type::IfcBoundedSurface) ) return IfcSchemaEntity(new IfcBoundedSurface(e)); + if ( e->is(Type::IfcBoundingBox) ) return IfcSchemaEntity(new IfcBoundingBox(e)); + if ( e->is(Type::IfcBoxedHalfSpace) ) return IfcSchemaEntity(new IfcBoxedHalfSpace(e)); + if ( e->is(Type::IfcBuilding) ) return IfcSchemaEntity(new IfcBuilding(e)); + if ( e->is(Type::IfcBuildingElement) ) return IfcSchemaEntity(new IfcBuildingElement(e)); + if ( e->is(Type::IfcBuildingElementComponent) ) return IfcSchemaEntity(new IfcBuildingElementComponent(e)); + if ( e->is(Type::IfcBuildingElementPart) ) return IfcSchemaEntity(new IfcBuildingElementPart(e)); + if ( e->is(Type::IfcBuildingElementProxy) ) return IfcSchemaEntity(new IfcBuildingElementProxy(e)); + if ( e->is(Type::IfcBuildingElementProxyType) ) return IfcSchemaEntity(new IfcBuildingElementProxyType(e)); + if ( e->is(Type::IfcBuildingElementType) ) return IfcSchemaEntity(new IfcBuildingElementType(e)); + if ( e->is(Type::IfcBuildingStorey) ) return IfcSchemaEntity(new IfcBuildingStorey(e)); + if ( e->is(Type::IfcCShapeProfileDef) ) return IfcSchemaEntity(new IfcCShapeProfileDef(e)); + if ( e->is(Type::IfcCableCarrierFittingType) ) return IfcSchemaEntity(new IfcCableCarrierFittingType(e)); + if ( e->is(Type::IfcCableCarrierSegmentType) ) return IfcSchemaEntity(new IfcCableCarrierSegmentType(e)); + if ( e->is(Type::IfcCableSegmentType) ) return IfcSchemaEntity(new IfcCableSegmentType(e)); + if ( e->is(Type::IfcCalendarDate) ) return IfcSchemaEntity(new IfcCalendarDate(e)); + if ( e->is(Type::IfcCartesianPoint) ) return IfcSchemaEntity(new IfcCartesianPoint(e)); + if ( e->is(Type::IfcCartesianTransformationOperator) ) return IfcSchemaEntity(new IfcCartesianTransformationOperator(e)); + if ( e->is(Type::IfcCartesianTransformationOperator2D) ) return IfcSchemaEntity(new IfcCartesianTransformationOperator2D(e)); + if ( e->is(Type::IfcCartesianTransformationOperator2DnonUniform) ) return IfcSchemaEntity(new IfcCartesianTransformationOperator2DnonUniform(e)); + if ( e->is(Type::IfcCartesianTransformationOperator3D) ) return IfcSchemaEntity(new IfcCartesianTransformationOperator3D(e)); + if ( e->is(Type::IfcCartesianTransformationOperator3DnonUniform) ) return IfcSchemaEntity(new IfcCartesianTransformationOperator3DnonUniform(e)); + if ( e->is(Type::IfcCenterLineProfileDef) ) return IfcSchemaEntity(new IfcCenterLineProfileDef(e)); + if ( e->is(Type::IfcChamferEdgeFeature) ) return IfcSchemaEntity(new IfcChamferEdgeFeature(e)); + if ( e->is(Type::IfcChillerType) ) return IfcSchemaEntity(new IfcChillerType(e)); + if ( e->is(Type::IfcCircle) ) return IfcSchemaEntity(new IfcCircle(e)); + if ( e->is(Type::IfcCircleHollowProfileDef) ) return IfcSchemaEntity(new IfcCircleHollowProfileDef(e)); + if ( e->is(Type::IfcCircleProfileDef) ) return IfcSchemaEntity(new IfcCircleProfileDef(e)); + if ( e->is(Type::IfcClassification) ) return IfcSchemaEntity(new IfcClassification(e)); + if ( e->is(Type::IfcClassificationItem) ) return IfcSchemaEntity(new IfcClassificationItem(e)); + if ( e->is(Type::IfcClassificationItemRelationship) ) return IfcSchemaEntity(new IfcClassificationItemRelationship(e)); + if ( e->is(Type::IfcClassificationNotation) ) return IfcSchemaEntity(new IfcClassificationNotation(e)); + if ( e->is(Type::IfcClassificationNotationFacet) ) return IfcSchemaEntity(new IfcClassificationNotationFacet(e)); + if ( e->is(Type::IfcClassificationReference) ) return IfcSchemaEntity(new IfcClassificationReference(e)); + if ( e->is(Type::IfcClosedShell) ) return IfcSchemaEntity(new IfcClosedShell(e)); + if ( e->is(Type::IfcCoilType) ) return IfcSchemaEntity(new IfcCoilType(e)); + if ( e->is(Type::IfcColourRgb) ) return IfcSchemaEntity(new IfcColourRgb(e)); + if ( e->is(Type::IfcColourSpecification) ) return IfcSchemaEntity(new IfcColourSpecification(e)); + if ( e->is(Type::IfcColumn) ) return IfcSchemaEntity(new IfcColumn(e)); + if ( e->is(Type::IfcColumnType) ) return IfcSchemaEntity(new IfcColumnType(e)); + if ( e->is(Type::IfcComplexProperty) ) return IfcSchemaEntity(new IfcComplexProperty(e)); + if ( e->is(Type::IfcCompositeCurve) ) return IfcSchemaEntity(new IfcCompositeCurve(e)); + if ( e->is(Type::IfcCompositeCurveSegment) ) return IfcSchemaEntity(new IfcCompositeCurveSegment(e)); + if ( e->is(Type::IfcCompositeProfileDef) ) return IfcSchemaEntity(new IfcCompositeProfileDef(e)); + if ( e->is(Type::IfcCompressorType) ) return IfcSchemaEntity(new IfcCompressorType(e)); + if ( e->is(Type::IfcCondenserType) ) return IfcSchemaEntity(new IfcCondenserType(e)); + if ( e->is(Type::IfcCondition) ) return IfcSchemaEntity(new IfcCondition(e)); + if ( e->is(Type::IfcConditionCriterion) ) return IfcSchemaEntity(new IfcConditionCriterion(e)); + if ( e->is(Type::IfcConic) ) return IfcSchemaEntity(new IfcConic(e)); + if ( e->is(Type::IfcConnectedFaceSet) ) return IfcSchemaEntity(new IfcConnectedFaceSet(e)); + if ( e->is(Type::IfcConnectionCurveGeometry) ) return IfcSchemaEntity(new IfcConnectionCurveGeometry(e)); + if ( e->is(Type::IfcConnectionGeometry) ) return IfcSchemaEntity(new IfcConnectionGeometry(e)); + if ( e->is(Type::IfcConnectionPointEccentricity) ) return IfcSchemaEntity(new IfcConnectionPointEccentricity(e)); + if ( e->is(Type::IfcConnectionPointGeometry) ) return IfcSchemaEntity(new IfcConnectionPointGeometry(e)); + if ( e->is(Type::IfcConnectionPortGeometry) ) return IfcSchemaEntity(new IfcConnectionPortGeometry(e)); + if ( e->is(Type::IfcConnectionSurfaceGeometry) ) return IfcSchemaEntity(new IfcConnectionSurfaceGeometry(e)); + if ( e->is(Type::IfcConstraint) ) return IfcSchemaEntity(new IfcConstraint(e)); + if ( e->is(Type::IfcConstraintAggregationRelationship) ) return IfcSchemaEntity(new IfcConstraintAggregationRelationship(e)); + if ( e->is(Type::IfcConstraintClassificationRelationship) ) return IfcSchemaEntity(new IfcConstraintClassificationRelationship(e)); + if ( e->is(Type::IfcConstraintRelationship) ) return IfcSchemaEntity(new IfcConstraintRelationship(e)); + if ( e->is(Type::IfcConstructionEquipmentResource) ) return IfcSchemaEntity(new IfcConstructionEquipmentResource(e)); + if ( e->is(Type::IfcConstructionMaterialResource) ) return IfcSchemaEntity(new IfcConstructionMaterialResource(e)); + if ( e->is(Type::IfcConstructionProductResource) ) return IfcSchemaEntity(new IfcConstructionProductResource(e)); + if ( e->is(Type::IfcConstructionResource) ) return IfcSchemaEntity(new IfcConstructionResource(e)); + if ( e->is(Type::IfcContextDependentUnit) ) return IfcSchemaEntity(new IfcContextDependentUnit(e)); + if ( e->is(Type::IfcControl) ) return IfcSchemaEntity(new IfcControl(e)); + if ( e->is(Type::IfcControllerType) ) return IfcSchemaEntity(new IfcControllerType(e)); + if ( e->is(Type::IfcConversionBasedUnit) ) return IfcSchemaEntity(new IfcConversionBasedUnit(e)); + if ( e->is(Type::IfcCooledBeamType) ) return IfcSchemaEntity(new IfcCooledBeamType(e)); + if ( e->is(Type::IfcCoolingTowerType) ) return IfcSchemaEntity(new IfcCoolingTowerType(e)); + if ( e->is(Type::IfcCoordinatedUniversalTimeOffset) ) return IfcSchemaEntity(new IfcCoordinatedUniversalTimeOffset(e)); + if ( e->is(Type::IfcCostItem) ) return IfcSchemaEntity(new IfcCostItem(e)); + if ( e->is(Type::IfcCostSchedule) ) return IfcSchemaEntity(new IfcCostSchedule(e)); + if ( e->is(Type::IfcCostValue) ) return IfcSchemaEntity(new IfcCostValue(e)); + if ( e->is(Type::IfcCovering) ) return IfcSchemaEntity(new IfcCovering(e)); + if ( e->is(Type::IfcCoveringType) ) return IfcSchemaEntity(new IfcCoveringType(e)); + if ( e->is(Type::IfcCraneRailAShapeProfileDef) ) return IfcSchemaEntity(new IfcCraneRailAShapeProfileDef(e)); + if ( e->is(Type::IfcCraneRailFShapeProfileDef) ) return IfcSchemaEntity(new IfcCraneRailFShapeProfileDef(e)); + if ( e->is(Type::IfcCrewResource) ) return IfcSchemaEntity(new IfcCrewResource(e)); + if ( e->is(Type::IfcCsgPrimitive3D) ) return IfcSchemaEntity(new IfcCsgPrimitive3D(e)); + if ( e->is(Type::IfcCsgSolid) ) return IfcSchemaEntity(new IfcCsgSolid(e)); + if ( e->is(Type::IfcCurrencyRelationship) ) return IfcSchemaEntity(new IfcCurrencyRelationship(e)); + if ( e->is(Type::IfcCurtainWall) ) return IfcSchemaEntity(new IfcCurtainWall(e)); + if ( e->is(Type::IfcCurtainWallType) ) return IfcSchemaEntity(new IfcCurtainWallType(e)); + if ( e->is(Type::IfcCurve) ) return IfcSchemaEntity(new IfcCurve(e)); + if ( e->is(Type::IfcCurveBoundedPlane) ) return IfcSchemaEntity(new IfcCurveBoundedPlane(e)); + if ( e->is(Type::IfcCurveStyle) ) return IfcSchemaEntity(new IfcCurveStyle(e)); + if ( e->is(Type::IfcCurveStyleFont) ) return IfcSchemaEntity(new IfcCurveStyleFont(e)); + if ( e->is(Type::IfcCurveStyleFontAndScaling) ) return IfcSchemaEntity(new IfcCurveStyleFontAndScaling(e)); + if ( e->is(Type::IfcCurveStyleFontPattern) ) return IfcSchemaEntity(new IfcCurveStyleFontPattern(e)); + if ( e->is(Type::IfcDamperType) ) return IfcSchemaEntity(new IfcDamperType(e)); + if ( e->is(Type::IfcDateAndTime) ) return IfcSchemaEntity(new IfcDateAndTime(e)); + if ( e->is(Type::IfcDefinedSymbol) ) return IfcSchemaEntity(new IfcDefinedSymbol(e)); + if ( e->is(Type::IfcDerivedProfileDef) ) return IfcSchemaEntity(new IfcDerivedProfileDef(e)); + if ( e->is(Type::IfcDerivedUnit) ) return IfcSchemaEntity(new IfcDerivedUnit(e)); + if ( e->is(Type::IfcDerivedUnitElement) ) return IfcSchemaEntity(new IfcDerivedUnitElement(e)); + if ( e->is(Type::IfcDiameterDimension) ) return IfcSchemaEntity(new IfcDiameterDimension(e)); + if ( e->is(Type::IfcDimensionCalloutRelationship) ) return IfcSchemaEntity(new IfcDimensionCalloutRelationship(e)); + if ( e->is(Type::IfcDimensionCurve) ) return IfcSchemaEntity(new IfcDimensionCurve(e)); + if ( e->is(Type::IfcDimensionCurveDirectedCallout) ) return IfcSchemaEntity(new IfcDimensionCurveDirectedCallout(e)); + if ( e->is(Type::IfcDimensionCurveTerminator) ) return IfcSchemaEntity(new IfcDimensionCurveTerminator(e)); + if ( e->is(Type::IfcDimensionPair) ) return IfcSchemaEntity(new IfcDimensionPair(e)); + if ( e->is(Type::IfcDimensionalExponents) ) return IfcSchemaEntity(new IfcDimensionalExponents(e)); + if ( e->is(Type::IfcDirection) ) return IfcSchemaEntity(new IfcDirection(e)); + if ( e->is(Type::IfcDiscreteAccessory) ) return IfcSchemaEntity(new IfcDiscreteAccessory(e)); + if ( e->is(Type::IfcDiscreteAccessoryType) ) return IfcSchemaEntity(new IfcDiscreteAccessoryType(e)); + if ( e->is(Type::IfcDistributionChamberElement) ) return IfcSchemaEntity(new IfcDistributionChamberElement(e)); + if ( e->is(Type::IfcDistributionChamberElementType) ) return IfcSchemaEntity(new IfcDistributionChamberElementType(e)); + if ( e->is(Type::IfcDistributionControlElement) ) return IfcSchemaEntity(new IfcDistributionControlElement(e)); + if ( e->is(Type::IfcDistributionControlElementType) ) return IfcSchemaEntity(new IfcDistributionControlElementType(e)); + if ( e->is(Type::IfcDistributionElement) ) return IfcSchemaEntity(new IfcDistributionElement(e)); + if ( e->is(Type::IfcDistributionElementType) ) return IfcSchemaEntity(new IfcDistributionElementType(e)); + if ( e->is(Type::IfcDistributionFlowElement) ) return IfcSchemaEntity(new IfcDistributionFlowElement(e)); + if ( e->is(Type::IfcDistributionFlowElementType) ) return IfcSchemaEntity(new IfcDistributionFlowElementType(e)); + if ( e->is(Type::IfcDistributionPort) ) return IfcSchemaEntity(new IfcDistributionPort(e)); + if ( e->is(Type::IfcDocumentElectronicFormat) ) return IfcSchemaEntity(new IfcDocumentElectronicFormat(e)); + if ( e->is(Type::IfcDocumentInformation) ) return IfcSchemaEntity(new IfcDocumentInformation(e)); + if ( e->is(Type::IfcDocumentInformationRelationship) ) return IfcSchemaEntity(new IfcDocumentInformationRelationship(e)); + if ( e->is(Type::IfcDocumentReference) ) return IfcSchemaEntity(new IfcDocumentReference(e)); + if ( e->is(Type::IfcDoor) ) return IfcSchemaEntity(new IfcDoor(e)); + if ( e->is(Type::IfcDoorLiningProperties) ) return IfcSchemaEntity(new IfcDoorLiningProperties(e)); + if ( e->is(Type::IfcDoorPanelProperties) ) return IfcSchemaEntity(new IfcDoorPanelProperties(e)); + if ( e->is(Type::IfcDoorStyle) ) return IfcSchemaEntity(new IfcDoorStyle(e)); + if ( e->is(Type::IfcDraughtingCallout) ) return IfcSchemaEntity(new IfcDraughtingCallout(e)); + if ( e->is(Type::IfcDraughtingCalloutRelationship) ) return IfcSchemaEntity(new IfcDraughtingCalloutRelationship(e)); + if ( e->is(Type::IfcDraughtingPreDefinedColour) ) return IfcSchemaEntity(new IfcDraughtingPreDefinedColour(e)); + if ( e->is(Type::IfcDraughtingPreDefinedCurveFont) ) return IfcSchemaEntity(new IfcDraughtingPreDefinedCurveFont(e)); + if ( e->is(Type::IfcDraughtingPreDefinedTextFont) ) return IfcSchemaEntity(new IfcDraughtingPreDefinedTextFont(e)); + if ( e->is(Type::IfcDuctFittingType) ) return IfcSchemaEntity(new IfcDuctFittingType(e)); + if ( e->is(Type::IfcDuctSegmentType) ) return IfcSchemaEntity(new IfcDuctSegmentType(e)); + if ( e->is(Type::IfcDuctSilencerType) ) return IfcSchemaEntity(new IfcDuctSilencerType(e)); + if ( e->is(Type::IfcEdge) ) return IfcSchemaEntity(new IfcEdge(e)); + if ( e->is(Type::IfcEdgeCurve) ) return IfcSchemaEntity(new IfcEdgeCurve(e)); + if ( e->is(Type::IfcEdgeFeature) ) return IfcSchemaEntity(new IfcEdgeFeature(e)); + if ( e->is(Type::IfcEdgeLoop) ) return IfcSchemaEntity(new IfcEdgeLoop(e)); + if ( e->is(Type::IfcElectricApplianceType) ) return IfcSchemaEntity(new IfcElectricApplianceType(e)); + if ( e->is(Type::IfcElectricDistributionPoint) ) return IfcSchemaEntity(new IfcElectricDistributionPoint(e)); + if ( e->is(Type::IfcElectricFlowStorageDeviceType) ) return IfcSchemaEntity(new IfcElectricFlowStorageDeviceType(e)); + if ( e->is(Type::IfcElectricGeneratorType) ) return IfcSchemaEntity(new IfcElectricGeneratorType(e)); + if ( e->is(Type::IfcElectricHeaterType) ) return IfcSchemaEntity(new IfcElectricHeaterType(e)); + if ( e->is(Type::IfcElectricMotorType) ) return IfcSchemaEntity(new IfcElectricMotorType(e)); + if ( e->is(Type::IfcElectricTimeControlType) ) return IfcSchemaEntity(new IfcElectricTimeControlType(e)); + if ( e->is(Type::IfcElectricalBaseProperties) ) return IfcSchemaEntity(new IfcElectricalBaseProperties(e)); + if ( e->is(Type::IfcElectricalCircuit) ) return IfcSchemaEntity(new IfcElectricalCircuit(e)); + if ( e->is(Type::IfcElectricalElement) ) return IfcSchemaEntity(new IfcElectricalElement(e)); + if ( e->is(Type::IfcElement) ) return IfcSchemaEntity(new IfcElement(e)); + if ( e->is(Type::IfcElementAssembly) ) return IfcSchemaEntity(new IfcElementAssembly(e)); + if ( e->is(Type::IfcElementComponent) ) return IfcSchemaEntity(new IfcElementComponent(e)); + if ( e->is(Type::IfcElementComponentType) ) return IfcSchemaEntity(new IfcElementComponentType(e)); + if ( e->is(Type::IfcElementQuantity) ) return IfcSchemaEntity(new IfcElementQuantity(e)); + if ( e->is(Type::IfcElementType) ) return IfcSchemaEntity(new IfcElementType(e)); + if ( e->is(Type::IfcElementarySurface) ) return IfcSchemaEntity(new IfcElementarySurface(e)); + if ( e->is(Type::IfcEllipse) ) return IfcSchemaEntity(new IfcEllipse(e)); + if ( e->is(Type::IfcEllipseProfileDef) ) return IfcSchemaEntity(new IfcEllipseProfileDef(e)); + if ( e->is(Type::IfcEnergyConversionDevice) ) return IfcSchemaEntity(new IfcEnergyConversionDevice(e)); + if ( e->is(Type::IfcEnergyConversionDeviceType) ) return IfcSchemaEntity(new IfcEnergyConversionDeviceType(e)); + if ( e->is(Type::IfcEnergyProperties) ) return IfcSchemaEntity(new IfcEnergyProperties(e)); + if ( e->is(Type::IfcEnvironmentalImpactValue) ) return IfcSchemaEntity(new IfcEnvironmentalImpactValue(e)); + if ( e->is(Type::IfcEquipmentElement) ) return IfcSchemaEntity(new IfcEquipmentElement(e)); + if ( e->is(Type::IfcEquipmentStandard) ) return IfcSchemaEntity(new IfcEquipmentStandard(e)); + if ( e->is(Type::IfcEvaporativeCoolerType) ) return IfcSchemaEntity(new IfcEvaporativeCoolerType(e)); + if ( e->is(Type::IfcEvaporatorType) ) return IfcSchemaEntity(new IfcEvaporatorType(e)); + if ( e->is(Type::IfcExtendedMaterialProperties) ) return IfcSchemaEntity(new IfcExtendedMaterialProperties(e)); + if ( e->is(Type::IfcExternalReference) ) return IfcSchemaEntity(new IfcExternalReference(e)); + if ( e->is(Type::IfcExternallyDefinedHatchStyle) ) return IfcSchemaEntity(new IfcExternallyDefinedHatchStyle(e)); + if ( e->is(Type::IfcExternallyDefinedSurfaceStyle) ) return IfcSchemaEntity(new IfcExternallyDefinedSurfaceStyle(e)); + if ( e->is(Type::IfcExternallyDefinedSymbol) ) return IfcSchemaEntity(new IfcExternallyDefinedSymbol(e)); + if ( e->is(Type::IfcExternallyDefinedTextFont) ) return IfcSchemaEntity(new IfcExternallyDefinedTextFont(e)); + if ( e->is(Type::IfcExtrudedAreaSolid) ) return IfcSchemaEntity(new IfcExtrudedAreaSolid(e)); + if ( e->is(Type::IfcFace) ) return IfcSchemaEntity(new IfcFace(e)); + if ( e->is(Type::IfcFaceBasedSurfaceModel) ) return IfcSchemaEntity(new IfcFaceBasedSurfaceModel(e)); + if ( e->is(Type::IfcFaceBound) ) return IfcSchemaEntity(new IfcFaceBound(e)); + if ( e->is(Type::IfcFaceOuterBound) ) return IfcSchemaEntity(new IfcFaceOuterBound(e)); + if ( e->is(Type::IfcFaceSurface) ) return IfcSchemaEntity(new IfcFaceSurface(e)); + if ( e->is(Type::IfcFacetedBrep) ) return IfcSchemaEntity(new IfcFacetedBrep(e)); + if ( e->is(Type::IfcFacetedBrepWithVoids) ) return IfcSchemaEntity(new IfcFacetedBrepWithVoids(e)); + if ( e->is(Type::IfcFailureConnectionCondition) ) return IfcSchemaEntity(new IfcFailureConnectionCondition(e)); + if ( e->is(Type::IfcFanType) ) return IfcSchemaEntity(new IfcFanType(e)); + if ( e->is(Type::IfcFastener) ) return IfcSchemaEntity(new IfcFastener(e)); + if ( e->is(Type::IfcFastenerType) ) return IfcSchemaEntity(new IfcFastenerType(e)); + if ( e->is(Type::IfcFeatureElement) ) return IfcSchemaEntity(new IfcFeatureElement(e)); + if ( e->is(Type::IfcFeatureElementAddition) ) return IfcSchemaEntity(new IfcFeatureElementAddition(e)); + if ( e->is(Type::IfcFeatureElementSubtraction) ) return IfcSchemaEntity(new IfcFeatureElementSubtraction(e)); + if ( e->is(Type::IfcFillAreaStyle) ) return IfcSchemaEntity(new IfcFillAreaStyle(e)); + if ( e->is(Type::IfcFillAreaStyleHatching) ) return IfcSchemaEntity(new IfcFillAreaStyleHatching(e)); + if ( e->is(Type::IfcFillAreaStyleTileSymbolWithStyle) ) return IfcSchemaEntity(new IfcFillAreaStyleTileSymbolWithStyle(e)); + if ( e->is(Type::IfcFillAreaStyleTiles) ) return IfcSchemaEntity(new IfcFillAreaStyleTiles(e)); + if ( e->is(Type::IfcFilterType) ) return IfcSchemaEntity(new IfcFilterType(e)); + if ( e->is(Type::IfcFireSuppressionTerminalType) ) return IfcSchemaEntity(new IfcFireSuppressionTerminalType(e)); + if ( e->is(Type::IfcFlowController) ) return IfcSchemaEntity(new IfcFlowController(e)); + if ( e->is(Type::IfcFlowControllerType) ) return IfcSchemaEntity(new IfcFlowControllerType(e)); + if ( e->is(Type::IfcFlowFitting) ) return IfcSchemaEntity(new IfcFlowFitting(e)); + if ( e->is(Type::IfcFlowFittingType) ) return IfcSchemaEntity(new IfcFlowFittingType(e)); + if ( e->is(Type::IfcFlowInstrumentType) ) return IfcSchemaEntity(new IfcFlowInstrumentType(e)); + if ( e->is(Type::IfcFlowMeterType) ) return IfcSchemaEntity(new IfcFlowMeterType(e)); + if ( e->is(Type::IfcFlowMovingDevice) ) return IfcSchemaEntity(new IfcFlowMovingDevice(e)); + if ( e->is(Type::IfcFlowMovingDeviceType) ) return IfcSchemaEntity(new IfcFlowMovingDeviceType(e)); + if ( e->is(Type::IfcFlowSegment) ) return IfcSchemaEntity(new IfcFlowSegment(e)); + if ( e->is(Type::IfcFlowSegmentType) ) return IfcSchemaEntity(new IfcFlowSegmentType(e)); + if ( e->is(Type::IfcFlowStorageDevice) ) return IfcSchemaEntity(new IfcFlowStorageDevice(e)); + if ( e->is(Type::IfcFlowStorageDeviceType) ) return IfcSchemaEntity(new IfcFlowStorageDeviceType(e)); + if ( e->is(Type::IfcFlowTerminal) ) return IfcSchemaEntity(new IfcFlowTerminal(e)); + if ( e->is(Type::IfcFlowTerminalType) ) return IfcSchemaEntity(new IfcFlowTerminalType(e)); + if ( e->is(Type::IfcFlowTreatmentDevice) ) return IfcSchemaEntity(new IfcFlowTreatmentDevice(e)); + if ( e->is(Type::IfcFlowTreatmentDeviceType) ) return IfcSchemaEntity(new IfcFlowTreatmentDeviceType(e)); + if ( e->is(Type::IfcFluidFlowProperties) ) return IfcSchemaEntity(new IfcFluidFlowProperties(e)); + if ( e->is(Type::IfcFooting) ) return IfcSchemaEntity(new IfcFooting(e)); + if ( e->is(Type::IfcFuelProperties) ) return IfcSchemaEntity(new IfcFuelProperties(e)); + if ( e->is(Type::IfcFurnishingElement) ) return IfcSchemaEntity(new IfcFurnishingElement(e)); + if ( e->is(Type::IfcFurnishingElementType) ) return IfcSchemaEntity(new IfcFurnishingElementType(e)); + if ( e->is(Type::IfcFurnitureStandard) ) return IfcSchemaEntity(new IfcFurnitureStandard(e)); + if ( e->is(Type::IfcFurnitureType) ) return IfcSchemaEntity(new IfcFurnitureType(e)); + if ( e->is(Type::IfcGasTerminalType) ) return IfcSchemaEntity(new IfcGasTerminalType(e)); + if ( e->is(Type::IfcGeneralMaterialProperties) ) return IfcSchemaEntity(new IfcGeneralMaterialProperties(e)); + if ( e->is(Type::IfcGeneralProfileProperties) ) return IfcSchemaEntity(new IfcGeneralProfileProperties(e)); + if ( e->is(Type::IfcGeometricCurveSet) ) return IfcSchemaEntity(new IfcGeometricCurveSet(e)); + if ( e->is(Type::IfcGeometricRepresentationContext) ) return IfcSchemaEntity(new IfcGeometricRepresentationContext(e)); + if ( e->is(Type::IfcGeometricRepresentationItem) ) return IfcSchemaEntity(new IfcGeometricRepresentationItem(e)); + if ( e->is(Type::IfcGeometricRepresentationSubContext) ) return IfcSchemaEntity(new IfcGeometricRepresentationSubContext(e)); + if ( e->is(Type::IfcGeometricSet) ) return IfcSchemaEntity(new IfcGeometricSet(e)); + if ( e->is(Type::IfcGrid) ) return IfcSchemaEntity(new IfcGrid(e)); + if ( e->is(Type::IfcGridAxis) ) return IfcSchemaEntity(new IfcGridAxis(e)); + if ( e->is(Type::IfcGridPlacement) ) return IfcSchemaEntity(new IfcGridPlacement(e)); + if ( e->is(Type::IfcGroup) ) return IfcSchemaEntity(new IfcGroup(e)); + if ( e->is(Type::IfcHalfSpaceSolid) ) return IfcSchemaEntity(new IfcHalfSpaceSolid(e)); + if ( e->is(Type::IfcHeatExchangerType) ) return IfcSchemaEntity(new IfcHeatExchangerType(e)); + if ( e->is(Type::IfcHumidifierType) ) return IfcSchemaEntity(new IfcHumidifierType(e)); + if ( e->is(Type::IfcHygroscopicMaterialProperties) ) return IfcSchemaEntity(new IfcHygroscopicMaterialProperties(e)); + if ( e->is(Type::IfcIShapeProfileDef) ) return IfcSchemaEntity(new IfcIShapeProfileDef(e)); + if ( e->is(Type::IfcImageTexture) ) return IfcSchemaEntity(new IfcImageTexture(e)); + if ( e->is(Type::IfcInventory) ) return IfcSchemaEntity(new IfcInventory(e)); + if ( e->is(Type::IfcIrregularTimeSeries) ) return IfcSchemaEntity(new IfcIrregularTimeSeries(e)); + if ( e->is(Type::IfcIrregularTimeSeriesValue) ) return IfcSchemaEntity(new IfcIrregularTimeSeriesValue(e)); + if ( e->is(Type::IfcJunctionBoxType) ) return IfcSchemaEntity(new IfcJunctionBoxType(e)); + if ( e->is(Type::IfcLShapeProfileDef) ) return IfcSchemaEntity(new IfcLShapeProfileDef(e)); + if ( e->is(Type::IfcLaborResource) ) return IfcSchemaEntity(new IfcLaborResource(e)); + if ( e->is(Type::IfcLampType) ) return IfcSchemaEntity(new IfcLampType(e)); + if ( e->is(Type::IfcLibraryInformation) ) return IfcSchemaEntity(new IfcLibraryInformation(e)); + if ( e->is(Type::IfcLibraryReference) ) return IfcSchemaEntity(new IfcLibraryReference(e)); + if ( e->is(Type::IfcLightDistributionData) ) return IfcSchemaEntity(new IfcLightDistributionData(e)); + if ( e->is(Type::IfcLightFixtureType) ) return IfcSchemaEntity(new IfcLightFixtureType(e)); + if ( e->is(Type::IfcLightIntensityDistribution) ) return IfcSchemaEntity(new IfcLightIntensityDistribution(e)); + if ( e->is(Type::IfcLightSource) ) return IfcSchemaEntity(new IfcLightSource(e)); + if ( e->is(Type::IfcLightSourceAmbient) ) return IfcSchemaEntity(new IfcLightSourceAmbient(e)); + if ( e->is(Type::IfcLightSourceDirectional) ) return IfcSchemaEntity(new IfcLightSourceDirectional(e)); + if ( e->is(Type::IfcLightSourceGoniometric) ) return IfcSchemaEntity(new IfcLightSourceGoniometric(e)); + if ( e->is(Type::IfcLightSourcePositional) ) return IfcSchemaEntity(new IfcLightSourcePositional(e)); + if ( e->is(Type::IfcLightSourceSpot) ) return IfcSchemaEntity(new IfcLightSourceSpot(e)); + if ( e->is(Type::IfcLine) ) return IfcSchemaEntity(new IfcLine(e)); + if ( e->is(Type::IfcLinearDimension) ) return IfcSchemaEntity(new IfcLinearDimension(e)); + if ( e->is(Type::IfcLocalPlacement) ) return IfcSchemaEntity(new IfcLocalPlacement(e)); + if ( e->is(Type::IfcLocalTime) ) return IfcSchemaEntity(new IfcLocalTime(e)); + if ( e->is(Type::IfcLoop) ) return IfcSchemaEntity(new IfcLoop(e)); + if ( e->is(Type::IfcManifoldSolidBrep) ) return IfcSchemaEntity(new IfcManifoldSolidBrep(e)); + if ( e->is(Type::IfcMappedItem) ) return IfcSchemaEntity(new IfcMappedItem(e)); + if ( e->is(Type::IfcMaterial) ) return IfcSchemaEntity(new IfcMaterial(e)); + if ( e->is(Type::IfcMaterialClassificationRelationship) ) return IfcSchemaEntity(new IfcMaterialClassificationRelationship(e)); + if ( e->is(Type::IfcMaterialDefinitionRepresentation) ) return IfcSchemaEntity(new IfcMaterialDefinitionRepresentation(e)); + if ( e->is(Type::IfcMaterialLayer) ) return IfcSchemaEntity(new IfcMaterialLayer(e)); + if ( e->is(Type::IfcMaterialLayerSet) ) return IfcSchemaEntity(new IfcMaterialLayerSet(e)); + if ( e->is(Type::IfcMaterialLayerSetUsage) ) return IfcSchemaEntity(new IfcMaterialLayerSetUsage(e)); + if ( e->is(Type::IfcMaterialList) ) return IfcSchemaEntity(new IfcMaterialList(e)); + if ( e->is(Type::IfcMaterialProperties) ) return IfcSchemaEntity(new IfcMaterialProperties(e)); + if ( e->is(Type::IfcMeasureWithUnit) ) return IfcSchemaEntity(new IfcMeasureWithUnit(e)); + if ( e->is(Type::IfcMechanicalConcreteMaterialProperties) ) return IfcSchemaEntity(new IfcMechanicalConcreteMaterialProperties(e)); + if ( e->is(Type::IfcMechanicalFastener) ) return IfcSchemaEntity(new IfcMechanicalFastener(e)); + if ( e->is(Type::IfcMechanicalFastenerType) ) return IfcSchemaEntity(new IfcMechanicalFastenerType(e)); + if ( e->is(Type::IfcMechanicalMaterialProperties) ) return IfcSchemaEntity(new IfcMechanicalMaterialProperties(e)); + if ( e->is(Type::IfcMechanicalSteelMaterialProperties) ) return IfcSchemaEntity(new IfcMechanicalSteelMaterialProperties(e)); + if ( e->is(Type::IfcMember) ) return IfcSchemaEntity(new IfcMember(e)); + if ( e->is(Type::IfcMemberType) ) return IfcSchemaEntity(new IfcMemberType(e)); + if ( e->is(Type::IfcMetric) ) return IfcSchemaEntity(new IfcMetric(e)); + if ( e->is(Type::IfcMonetaryUnit) ) return IfcSchemaEntity(new IfcMonetaryUnit(e)); + if ( e->is(Type::IfcMotorConnectionType) ) return IfcSchemaEntity(new IfcMotorConnectionType(e)); + if ( e->is(Type::IfcMove) ) return IfcSchemaEntity(new IfcMove(e)); + if ( e->is(Type::IfcNamedUnit) ) return IfcSchemaEntity(new IfcNamedUnit(e)); + if ( e->is(Type::IfcObject) ) return IfcSchemaEntity(new IfcObject(e)); + if ( e->is(Type::IfcObjectDefinition) ) return IfcSchemaEntity(new IfcObjectDefinition(e)); + if ( e->is(Type::IfcObjectPlacement) ) return IfcSchemaEntity(new IfcObjectPlacement(e)); + if ( e->is(Type::IfcObjective) ) return IfcSchemaEntity(new IfcObjective(e)); + if ( e->is(Type::IfcOccupant) ) return IfcSchemaEntity(new IfcOccupant(e)); + if ( e->is(Type::IfcOffsetCurve2D) ) return IfcSchemaEntity(new IfcOffsetCurve2D(e)); + if ( e->is(Type::IfcOffsetCurve3D) ) return IfcSchemaEntity(new IfcOffsetCurve3D(e)); + if ( e->is(Type::IfcOneDirectionRepeatFactor) ) return IfcSchemaEntity(new IfcOneDirectionRepeatFactor(e)); + if ( e->is(Type::IfcOpenShell) ) return IfcSchemaEntity(new IfcOpenShell(e)); + if ( e->is(Type::IfcOpeningElement) ) return IfcSchemaEntity(new IfcOpeningElement(e)); + if ( e->is(Type::IfcOpticalMaterialProperties) ) return IfcSchemaEntity(new IfcOpticalMaterialProperties(e)); + if ( e->is(Type::IfcOrderAction) ) return IfcSchemaEntity(new IfcOrderAction(e)); + if ( e->is(Type::IfcOrganization) ) return IfcSchemaEntity(new IfcOrganization(e)); + if ( e->is(Type::IfcOrganizationRelationship) ) return IfcSchemaEntity(new IfcOrganizationRelationship(e)); + if ( e->is(Type::IfcOrientedEdge) ) return IfcSchemaEntity(new IfcOrientedEdge(e)); + if ( e->is(Type::IfcOutletType) ) return IfcSchemaEntity(new IfcOutletType(e)); + if ( e->is(Type::IfcOwnerHistory) ) return IfcSchemaEntity(new IfcOwnerHistory(e)); + if ( e->is(Type::IfcParameterizedProfileDef) ) return IfcSchemaEntity(new IfcParameterizedProfileDef(e)); + if ( e->is(Type::IfcPath) ) return IfcSchemaEntity(new IfcPath(e)); + if ( e->is(Type::IfcPerformanceHistory) ) return IfcSchemaEntity(new IfcPerformanceHistory(e)); + if ( e->is(Type::IfcPermeableCoveringProperties) ) return IfcSchemaEntity(new IfcPermeableCoveringProperties(e)); + if ( e->is(Type::IfcPermit) ) return IfcSchemaEntity(new IfcPermit(e)); + if ( e->is(Type::IfcPerson) ) return IfcSchemaEntity(new IfcPerson(e)); + if ( e->is(Type::IfcPersonAndOrganization) ) return IfcSchemaEntity(new IfcPersonAndOrganization(e)); + if ( e->is(Type::IfcPhysicalComplexQuantity) ) return IfcSchemaEntity(new IfcPhysicalComplexQuantity(e)); + if ( e->is(Type::IfcPhysicalQuantity) ) return IfcSchemaEntity(new IfcPhysicalQuantity(e)); + if ( e->is(Type::IfcPhysicalSimpleQuantity) ) return IfcSchemaEntity(new IfcPhysicalSimpleQuantity(e)); + if ( e->is(Type::IfcPile) ) return IfcSchemaEntity(new IfcPile(e)); + if ( e->is(Type::IfcPipeFittingType) ) return IfcSchemaEntity(new IfcPipeFittingType(e)); + if ( e->is(Type::IfcPipeSegmentType) ) return IfcSchemaEntity(new IfcPipeSegmentType(e)); + if ( e->is(Type::IfcPixelTexture) ) return IfcSchemaEntity(new IfcPixelTexture(e)); + if ( e->is(Type::IfcPlacement) ) return IfcSchemaEntity(new IfcPlacement(e)); + if ( e->is(Type::IfcPlanarBox) ) return IfcSchemaEntity(new IfcPlanarBox(e)); + if ( e->is(Type::IfcPlanarExtent) ) return IfcSchemaEntity(new IfcPlanarExtent(e)); + if ( e->is(Type::IfcPlane) ) return IfcSchemaEntity(new IfcPlane(e)); + if ( e->is(Type::IfcPlate) ) return IfcSchemaEntity(new IfcPlate(e)); + if ( e->is(Type::IfcPlateType) ) return IfcSchemaEntity(new IfcPlateType(e)); + if ( e->is(Type::IfcPoint) ) return IfcSchemaEntity(new IfcPoint(e)); + if ( e->is(Type::IfcPointOnCurve) ) return IfcSchemaEntity(new IfcPointOnCurve(e)); + if ( e->is(Type::IfcPointOnSurface) ) return IfcSchemaEntity(new IfcPointOnSurface(e)); + if ( e->is(Type::IfcPolyLoop) ) return IfcSchemaEntity(new IfcPolyLoop(e)); + if ( e->is(Type::IfcPolygonalBoundedHalfSpace) ) return IfcSchemaEntity(new IfcPolygonalBoundedHalfSpace(e)); + if ( e->is(Type::IfcPolyline) ) return IfcSchemaEntity(new IfcPolyline(e)); + if ( e->is(Type::IfcPort) ) return IfcSchemaEntity(new IfcPort(e)); + if ( e->is(Type::IfcPostalAddress) ) return IfcSchemaEntity(new IfcPostalAddress(e)); + if ( e->is(Type::IfcPreDefinedColour) ) return IfcSchemaEntity(new IfcPreDefinedColour(e)); + if ( e->is(Type::IfcPreDefinedCurveFont) ) return IfcSchemaEntity(new IfcPreDefinedCurveFont(e)); + if ( e->is(Type::IfcPreDefinedDimensionSymbol) ) return IfcSchemaEntity(new IfcPreDefinedDimensionSymbol(e)); + if ( e->is(Type::IfcPreDefinedItem) ) return IfcSchemaEntity(new IfcPreDefinedItem(e)); + if ( e->is(Type::IfcPreDefinedPointMarkerSymbol) ) return IfcSchemaEntity(new IfcPreDefinedPointMarkerSymbol(e)); + if ( e->is(Type::IfcPreDefinedSymbol) ) return IfcSchemaEntity(new IfcPreDefinedSymbol(e)); + if ( e->is(Type::IfcPreDefinedTerminatorSymbol) ) return IfcSchemaEntity(new IfcPreDefinedTerminatorSymbol(e)); + if ( e->is(Type::IfcPreDefinedTextFont) ) return IfcSchemaEntity(new IfcPreDefinedTextFont(e)); + if ( e->is(Type::IfcPresentationLayerAssignment) ) return IfcSchemaEntity(new IfcPresentationLayerAssignment(e)); + if ( e->is(Type::IfcPresentationLayerWithStyle) ) return IfcSchemaEntity(new IfcPresentationLayerWithStyle(e)); + if ( e->is(Type::IfcPresentationStyle) ) return IfcSchemaEntity(new IfcPresentationStyle(e)); + if ( e->is(Type::IfcPresentationStyleAssignment) ) return IfcSchemaEntity(new IfcPresentationStyleAssignment(e)); + if ( e->is(Type::IfcProcedure) ) return IfcSchemaEntity(new IfcProcedure(e)); + if ( e->is(Type::IfcProcess) ) return IfcSchemaEntity(new IfcProcess(e)); + if ( e->is(Type::IfcProduct) ) return IfcSchemaEntity(new IfcProduct(e)); + if ( e->is(Type::IfcProductDefinitionShape) ) return IfcSchemaEntity(new IfcProductDefinitionShape(e)); + if ( e->is(Type::IfcProductRepresentation) ) return IfcSchemaEntity(new IfcProductRepresentation(e)); + if ( e->is(Type::IfcProductsOfCombustionProperties) ) return IfcSchemaEntity(new IfcProductsOfCombustionProperties(e)); + if ( e->is(Type::IfcProfileDef) ) return IfcSchemaEntity(new IfcProfileDef(e)); + if ( e->is(Type::IfcProfileProperties) ) return IfcSchemaEntity(new IfcProfileProperties(e)); + if ( e->is(Type::IfcProject) ) return IfcSchemaEntity(new IfcProject(e)); + if ( e->is(Type::IfcProjectOrder) ) return IfcSchemaEntity(new IfcProjectOrder(e)); + if ( e->is(Type::IfcProjectOrderRecord) ) return IfcSchemaEntity(new IfcProjectOrderRecord(e)); + if ( e->is(Type::IfcProjectionCurve) ) return IfcSchemaEntity(new IfcProjectionCurve(e)); + if ( e->is(Type::IfcProjectionElement) ) return IfcSchemaEntity(new IfcProjectionElement(e)); + if ( e->is(Type::IfcProperty) ) return IfcSchemaEntity(new IfcProperty(e)); + if ( e->is(Type::IfcPropertyBoundedValue) ) return IfcSchemaEntity(new IfcPropertyBoundedValue(e)); + if ( e->is(Type::IfcPropertyConstraintRelationship) ) return IfcSchemaEntity(new IfcPropertyConstraintRelationship(e)); + if ( e->is(Type::IfcPropertyDefinition) ) return IfcSchemaEntity(new IfcPropertyDefinition(e)); + if ( e->is(Type::IfcPropertyDependencyRelationship) ) return IfcSchemaEntity(new IfcPropertyDependencyRelationship(e)); + if ( e->is(Type::IfcPropertyEnumeratedValue) ) return IfcSchemaEntity(new IfcPropertyEnumeratedValue(e)); + if ( e->is(Type::IfcPropertyEnumeration) ) return IfcSchemaEntity(new IfcPropertyEnumeration(e)); + if ( e->is(Type::IfcPropertyListValue) ) return IfcSchemaEntity(new IfcPropertyListValue(e)); + if ( e->is(Type::IfcPropertyReferenceValue) ) return IfcSchemaEntity(new IfcPropertyReferenceValue(e)); + if ( e->is(Type::IfcPropertySet) ) return IfcSchemaEntity(new IfcPropertySet(e)); + if ( e->is(Type::IfcPropertySetDefinition) ) return IfcSchemaEntity(new IfcPropertySetDefinition(e)); + if ( e->is(Type::IfcPropertySingleValue) ) return IfcSchemaEntity(new IfcPropertySingleValue(e)); + if ( e->is(Type::IfcPropertyTableValue) ) return IfcSchemaEntity(new IfcPropertyTableValue(e)); + if ( e->is(Type::IfcProtectiveDeviceType) ) return IfcSchemaEntity(new IfcProtectiveDeviceType(e)); + if ( e->is(Type::IfcProxy) ) return IfcSchemaEntity(new IfcProxy(e)); + if ( e->is(Type::IfcPumpType) ) return IfcSchemaEntity(new IfcPumpType(e)); + if ( e->is(Type::IfcQuantityArea) ) return IfcSchemaEntity(new IfcQuantityArea(e)); + if ( e->is(Type::IfcQuantityCount) ) return IfcSchemaEntity(new IfcQuantityCount(e)); + if ( e->is(Type::IfcQuantityLength) ) return IfcSchemaEntity(new IfcQuantityLength(e)); + if ( e->is(Type::IfcQuantityTime) ) return IfcSchemaEntity(new IfcQuantityTime(e)); + if ( e->is(Type::IfcQuantityVolume) ) return IfcSchemaEntity(new IfcQuantityVolume(e)); + if ( e->is(Type::IfcQuantityWeight) ) return IfcSchemaEntity(new IfcQuantityWeight(e)); + if ( e->is(Type::IfcRadiusDimension) ) return IfcSchemaEntity(new IfcRadiusDimension(e)); + if ( e->is(Type::IfcRailing) ) return IfcSchemaEntity(new IfcRailing(e)); + if ( e->is(Type::IfcRailingType) ) return IfcSchemaEntity(new IfcRailingType(e)); + if ( e->is(Type::IfcRamp) ) return IfcSchemaEntity(new IfcRamp(e)); + if ( e->is(Type::IfcRampFlight) ) return IfcSchemaEntity(new IfcRampFlight(e)); + if ( e->is(Type::IfcRampFlightType) ) return IfcSchemaEntity(new IfcRampFlightType(e)); + if ( e->is(Type::IfcRationalBezierCurve) ) return IfcSchemaEntity(new IfcRationalBezierCurve(e)); + if ( e->is(Type::IfcRectangleHollowProfileDef) ) return IfcSchemaEntity(new IfcRectangleHollowProfileDef(e)); + if ( e->is(Type::IfcRectangleProfileDef) ) return IfcSchemaEntity(new IfcRectangleProfileDef(e)); + if ( e->is(Type::IfcRectangularPyramid) ) return IfcSchemaEntity(new IfcRectangularPyramid(e)); + if ( e->is(Type::IfcRectangularTrimmedSurface) ) return IfcSchemaEntity(new IfcRectangularTrimmedSurface(e)); + if ( e->is(Type::IfcReferencesValueDocument) ) return IfcSchemaEntity(new IfcReferencesValueDocument(e)); + if ( e->is(Type::IfcRegularTimeSeries) ) return IfcSchemaEntity(new IfcRegularTimeSeries(e)); + if ( e->is(Type::IfcReinforcementBarProperties) ) return IfcSchemaEntity(new IfcReinforcementBarProperties(e)); + if ( e->is(Type::IfcReinforcementDefinitionProperties) ) return IfcSchemaEntity(new IfcReinforcementDefinitionProperties(e)); + if ( e->is(Type::IfcReinforcingBar) ) return IfcSchemaEntity(new IfcReinforcingBar(e)); + if ( e->is(Type::IfcReinforcingElement) ) return IfcSchemaEntity(new IfcReinforcingElement(e)); + if ( e->is(Type::IfcReinforcingMesh) ) return IfcSchemaEntity(new IfcReinforcingMesh(e)); + if ( e->is(Type::IfcRelAggregates) ) return IfcSchemaEntity(new IfcRelAggregates(e)); + if ( e->is(Type::IfcRelAssigns) ) return IfcSchemaEntity(new IfcRelAssigns(e)); + if ( e->is(Type::IfcRelAssignsTasks) ) return IfcSchemaEntity(new IfcRelAssignsTasks(e)); + if ( e->is(Type::IfcRelAssignsToActor) ) return IfcSchemaEntity(new IfcRelAssignsToActor(e)); + if ( e->is(Type::IfcRelAssignsToControl) ) return IfcSchemaEntity(new IfcRelAssignsToControl(e)); + if ( e->is(Type::IfcRelAssignsToGroup) ) return IfcSchemaEntity(new IfcRelAssignsToGroup(e)); + if ( e->is(Type::IfcRelAssignsToProcess) ) return IfcSchemaEntity(new IfcRelAssignsToProcess(e)); + if ( e->is(Type::IfcRelAssignsToProduct) ) return IfcSchemaEntity(new IfcRelAssignsToProduct(e)); + if ( e->is(Type::IfcRelAssignsToProjectOrder) ) return IfcSchemaEntity(new IfcRelAssignsToProjectOrder(e)); + if ( e->is(Type::IfcRelAssignsToResource) ) return IfcSchemaEntity(new IfcRelAssignsToResource(e)); + if ( e->is(Type::IfcRelAssociates) ) return IfcSchemaEntity(new IfcRelAssociates(e)); + if ( e->is(Type::IfcRelAssociatesAppliedValue) ) return IfcSchemaEntity(new IfcRelAssociatesAppliedValue(e)); + if ( e->is(Type::IfcRelAssociatesApproval) ) return IfcSchemaEntity(new IfcRelAssociatesApproval(e)); + if ( e->is(Type::IfcRelAssociatesClassification) ) return IfcSchemaEntity(new IfcRelAssociatesClassification(e)); + if ( e->is(Type::IfcRelAssociatesConstraint) ) return IfcSchemaEntity(new IfcRelAssociatesConstraint(e)); + if ( e->is(Type::IfcRelAssociatesDocument) ) return IfcSchemaEntity(new IfcRelAssociatesDocument(e)); + if ( e->is(Type::IfcRelAssociatesLibrary) ) return IfcSchemaEntity(new IfcRelAssociatesLibrary(e)); + if ( e->is(Type::IfcRelAssociatesMaterial) ) return IfcSchemaEntity(new IfcRelAssociatesMaterial(e)); + if ( e->is(Type::IfcRelAssociatesProfileProperties) ) return IfcSchemaEntity(new IfcRelAssociatesProfileProperties(e)); + if ( e->is(Type::IfcRelConnects) ) return IfcSchemaEntity(new IfcRelConnects(e)); + if ( e->is(Type::IfcRelConnectsElements) ) return IfcSchemaEntity(new IfcRelConnectsElements(e)); + if ( e->is(Type::IfcRelConnectsPathElements) ) return IfcSchemaEntity(new IfcRelConnectsPathElements(e)); + if ( e->is(Type::IfcRelConnectsPortToElement) ) return IfcSchemaEntity(new IfcRelConnectsPortToElement(e)); + if ( e->is(Type::IfcRelConnectsPorts) ) return IfcSchemaEntity(new IfcRelConnectsPorts(e)); + if ( e->is(Type::IfcRelConnectsStructuralActivity) ) return IfcSchemaEntity(new IfcRelConnectsStructuralActivity(e)); + if ( e->is(Type::IfcRelConnectsStructuralElement) ) return IfcSchemaEntity(new IfcRelConnectsStructuralElement(e)); + if ( e->is(Type::IfcRelConnectsStructuralMember) ) return IfcSchemaEntity(new IfcRelConnectsStructuralMember(e)); + if ( e->is(Type::IfcRelConnectsWithEccentricity) ) return IfcSchemaEntity(new IfcRelConnectsWithEccentricity(e)); + if ( e->is(Type::IfcRelConnectsWithRealizingElements) ) return IfcSchemaEntity(new IfcRelConnectsWithRealizingElements(e)); + if ( e->is(Type::IfcRelContainedInSpatialStructure) ) return IfcSchemaEntity(new IfcRelContainedInSpatialStructure(e)); + if ( e->is(Type::IfcRelCoversBldgElements) ) return IfcSchemaEntity(new IfcRelCoversBldgElements(e)); + if ( e->is(Type::IfcRelCoversSpaces) ) return IfcSchemaEntity(new IfcRelCoversSpaces(e)); + if ( e->is(Type::IfcRelDecomposes) ) return IfcSchemaEntity(new IfcRelDecomposes(e)); + if ( e->is(Type::IfcRelDefines) ) return IfcSchemaEntity(new IfcRelDefines(e)); + if ( e->is(Type::IfcRelDefinesByProperties) ) return IfcSchemaEntity(new IfcRelDefinesByProperties(e)); + if ( e->is(Type::IfcRelDefinesByType) ) return IfcSchemaEntity(new IfcRelDefinesByType(e)); + if ( e->is(Type::IfcRelFillsElement) ) return IfcSchemaEntity(new IfcRelFillsElement(e)); + if ( e->is(Type::IfcRelFlowControlElements) ) return IfcSchemaEntity(new IfcRelFlowControlElements(e)); + if ( e->is(Type::IfcRelInteractionRequirements) ) return IfcSchemaEntity(new IfcRelInteractionRequirements(e)); + if ( e->is(Type::IfcRelNests) ) return IfcSchemaEntity(new IfcRelNests(e)); + if ( e->is(Type::IfcRelOccupiesSpaces) ) return IfcSchemaEntity(new IfcRelOccupiesSpaces(e)); + if ( e->is(Type::IfcRelOverridesProperties) ) return IfcSchemaEntity(new IfcRelOverridesProperties(e)); + if ( e->is(Type::IfcRelProjectsElement) ) return IfcSchemaEntity(new IfcRelProjectsElement(e)); + if ( e->is(Type::IfcRelReferencedInSpatialStructure) ) return IfcSchemaEntity(new IfcRelReferencedInSpatialStructure(e)); + if ( e->is(Type::IfcRelSchedulesCostItems) ) return IfcSchemaEntity(new IfcRelSchedulesCostItems(e)); + if ( e->is(Type::IfcRelSequence) ) return IfcSchemaEntity(new IfcRelSequence(e)); + if ( e->is(Type::IfcRelServicesBuildings) ) return IfcSchemaEntity(new IfcRelServicesBuildings(e)); + if ( e->is(Type::IfcRelSpaceBoundary) ) return IfcSchemaEntity(new IfcRelSpaceBoundary(e)); + if ( e->is(Type::IfcRelVoidsElement) ) return IfcSchemaEntity(new IfcRelVoidsElement(e)); + if ( e->is(Type::IfcRelationship) ) return IfcSchemaEntity(new IfcRelationship(e)); + if ( e->is(Type::IfcRelaxation) ) return IfcSchemaEntity(new IfcRelaxation(e)); + if ( e->is(Type::IfcRepresentation) ) return IfcSchemaEntity(new IfcRepresentation(e)); + if ( e->is(Type::IfcRepresentationContext) ) return IfcSchemaEntity(new IfcRepresentationContext(e)); + if ( e->is(Type::IfcRepresentationItem) ) return IfcSchemaEntity(new IfcRepresentationItem(e)); + if ( e->is(Type::IfcRepresentationMap) ) return IfcSchemaEntity(new IfcRepresentationMap(e)); + if ( e->is(Type::IfcResource) ) return IfcSchemaEntity(new IfcResource(e)); + if ( e->is(Type::IfcRevolvedAreaSolid) ) return IfcSchemaEntity(new IfcRevolvedAreaSolid(e)); + if ( e->is(Type::IfcRibPlateProfileProperties) ) return IfcSchemaEntity(new IfcRibPlateProfileProperties(e)); + if ( e->is(Type::IfcRightCircularCone) ) return IfcSchemaEntity(new IfcRightCircularCone(e)); + if ( e->is(Type::IfcRightCircularCylinder) ) return IfcSchemaEntity(new IfcRightCircularCylinder(e)); + if ( e->is(Type::IfcRoof) ) return IfcSchemaEntity(new IfcRoof(e)); + if ( e->is(Type::IfcRoot) ) return IfcSchemaEntity(new IfcRoot(e)); + if ( e->is(Type::IfcRoundedEdgeFeature) ) return IfcSchemaEntity(new IfcRoundedEdgeFeature(e)); + if ( e->is(Type::IfcRoundedRectangleProfileDef) ) return IfcSchemaEntity(new IfcRoundedRectangleProfileDef(e)); + if ( e->is(Type::IfcSIUnit) ) return IfcSchemaEntity(new IfcSIUnit(e)); + if ( e->is(Type::IfcSanitaryTerminalType) ) return IfcSchemaEntity(new IfcSanitaryTerminalType(e)); + if ( e->is(Type::IfcScheduleTimeControl) ) return IfcSchemaEntity(new IfcScheduleTimeControl(e)); + if ( e->is(Type::IfcSectionProperties) ) return IfcSchemaEntity(new IfcSectionProperties(e)); + if ( e->is(Type::IfcSectionReinforcementProperties) ) return IfcSchemaEntity(new IfcSectionReinforcementProperties(e)); + if ( e->is(Type::IfcSectionedSpine) ) return IfcSchemaEntity(new IfcSectionedSpine(e)); + if ( e->is(Type::IfcSensorType) ) return IfcSchemaEntity(new IfcSensorType(e)); + if ( e->is(Type::IfcServiceLife) ) return IfcSchemaEntity(new IfcServiceLife(e)); + if ( e->is(Type::IfcServiceLifeFactor) ) return IfcSchemaEntity(new IfcServiceLifeFactor(e)); + if ( e->is(Type::IfcShapeAspect) ) return IfcSchemaEntity(new IfcShapeAspect(e)); + if ( e->is(Type::IfcShapeModel) ) return IfcSchemaEntity(new IfcShapeModel(e)); + if ( e->is(Type::IfcShapeRepresentation) ) return IfcSchemaEntity(new IfcShapeRepresentation(e)); + if ( e->is(Type::IfcShellBasedSurfaceModel) ) return IfcSchemaEntity(new IfcShellBasedSurfaceModel(e)); + if ( e->is(Type::IfcSimpleProperty) ) return IfcSchemaEntity(new IfcSimpleProperty(e)); + if ( e->is(Type::IfcSite) ) return IfcSchemaEntity(new IfcSite(e)); + if ( e->is(Type::IfcSlab) ) return IfcSchemaEntity(new IfcSlab(e)); + if ( e->is(Type::IfcSlabType) ) return IfcSchemaEntity(new IfcSlabType(e)); + if ( e->is(Type::IfcSlippageConnectionCondition) ) return IfcSchemaEntity(new IfcSlippageConnectionCondition(e)); + if ( e->is(Type::IfcSolidModel) ) return IfcSchemaEntity(new IfcSolidModel(e)); + if ( e->is(Type::IfcSoundProperties) ) return IfcSchemaEntity(new IfcSoundProperties(e)); + if ( e->is(Type::IfcSoundValue) ) return IfcSchemaEntity(new IfcSoundValue(e)); + if ( e->is(Type::IfcSpace) ) return IfcSchemaEntity(new IfcSpace(e)); + if ( e->is(Type::IfcSpaceHeaterType) ) return IfcSchemaEntity(new IfcSpaceHeaterType(e)); + if ( e->is(Type::IfcSpaceProgram) ) return IfcSchemaEntity(new IfcSpaceProgram(e)); + if ( e->is(Type::IfcSpaceThermalLoadProperties) ) return IfcSchemaEntity(new IfcSpaceThermalLoadProperties(e)); + if ( e->is(Type::IfcSpaceType) ) return IfcSchemaEntity(new IfcSpaceType(e)); + if ( e->is(Type::IfcSpatialStructureElement) ) return IfcSchemaEntity(new IfcSpatialStructureElement(e)); + if ( e->is(Type::IfcSpatialStructureElementType) ) return IfcSchemaEntity(new IfcSpatialStructureElementType(e)); + if ( e->is(Type::IfcSphere) ) return IfcSchemaEntity(new IfcSphere(e)); + if ( e->is(Type::IfcStackTerminalType) ) return IfcSchemaEntity(new IfcStackTerminalType(e)); + if ( e->is(Type::IfcStair) ) return IfcSchemaEntity(new IfcStair(e)); + if ( e->is(Type::IfcStairFlight) ) return IfcSchemaEntity(new IfcStairFlight(e)); + if ( e->is(Type::IfcStairFlightType) ) return IfcSchemaEntity(new IfcStairFlightType(e)); + if ( e->is(Type::IfcStructuralAction) ) return IfcSchemaEntity(new IfcStructuralAction(e)); + if ( e->is(Type::IfcStructuralActivity) ) return IfcSchemaEntity(new IfcStructuralActivity(e)); + if ( e->is(Type::IfcStructuralAnalysisModel) ) return IfcSchemaEntity(new IfcStructuralAnalysisModel(e)); + if ( e->is(Type::IfcStructuralConnection) ) return IfcSchemaEntity(new IfcStructuralConnection(e)); + if ( e->is(Type::IfcStructuralConnectionCondition) ) return IfcSchemaEntity(new IfcStructuralConnectionCondition(e)); + if ( e->is(Type::IfcStructuralCurveConnection) ) return IfcSchemaEntity(new IfcStructuralCurveConnection(e)); + if ( e->is(Type::IfcStructuralCurveMember) ) return IfcSchemaEntity(new IfcStructuralCurveMember(e)); + if ( e->is(Type::IfcStructuralCurveMemberVarying) ) return IfcSchemaEntity(new IfcStructuralCurveMemberVarying(e)); + if ( e->is(Type::IfcStructuralItem) ) return IfcSchemaEntity(new IfcStructuralItem(e)); + if ( e->is(Type::IfcStructuralLinearAction) ) return IfcSchemaEntity(new IfcStructuralLinearAction(e)); + if ( e->is(Type::IfcStructuralLinearActionVarying) ) return IfcSchemaEntity(new IfcStructuralLinearActionVarying(e)); + if ( e->is(Type::IfcStructuralLoad) ) return IfcSchemaEntity(new IfcStructuralLoad(e)); + if ( e->is(Type::IfcStructuralLoadGroup) ) return IfcSchemaEntity(new IfcStructuralLoadGroup(e)); + if ( e->is(Type::IfcStructuralLoadLinearForce) ) return IfcSchemaEntity(new IfcStructuralLoadLinearForce(e)); + if ( e->is(Type::IfcStructuralLoadPlanarForce) ) return IfcSchemaEntity(new IfcStructuralLoadPlanarForce(e)); + if ( e->is(Type::IfcStructuralLoadSingleDisplacement) ) return IfcSchemaEntity(new IfcStructuralLoadSingleDisplacement(e)); + if ( e->is(Type::IfcStructuralLoadSingleDisplacementDistortion) ) return IfcSchemaEntity(new IfcStructuralLoadSingleDisplacementDistortion(e)); + if ( e->is(Type::IfcStructuralLoadSingleForce) ) return IfcSchemaEntity(new IfcStructuralLoadSingleForce(e)); + if ( e->is(Type::IfcStructuralLoadSingleForceWarping) ) return IfcSchemaEntity(new IfcStructuralLoadSingleForceWarping(e)); + if ( e->is(Type::IfcStructuralLoadStatic) ) return IfcSchemaEntity(new IfcStructuralLoadStatic(e)); + if ( e->is(Type::IfcStructuralLoadTemperature) ) return IfcSchemaEntity(new IfcStructuralLoadTemperature(e)); + if ( e->is(Type::IfcStructuralMember) ) return IfcSchemaEntity(new IfcStructuralMember(e)); + if ( e->is(Type::IfcStructuralPlanarAction) ) return IfcSchemaEntity(new IfcStructuralPlanarAction(e)); + if ( e->is(Type::IfcStructuralPlanarActionVarying) ) return IfcSchemaEntity(new IfcStructuralPlanarActionVarying(e)); + if ( e->is(Type::IfcStructuralPointAction) ) return IfcSchemaEntity(new IfcStructuralPointAction(e)); + if ( e->is(Type::IfcStructuralPointConnection) ) return IfcSchemaEntity(new IfcStructuralPointConnection(e)); + if ( e->is(Type::IfcStructuralPointReaction) ) return IfcSchemaEntity(new IfcStructuralPointReaction(e)); + if ( e->is(Type::IfcStructuralProfileProperties) ) return IfcSchemaEntity(new IfcStructuralProfileProperties(e)); + if ( e->is(Type::IfcStructuralReaction) ) return IfcSchemaEntity(new IfcStructuralReaction(e)); + if ( e->is(Type::IfcStructuralResultGroup) ) return IfcSchemaEntity(new IfcStructuralResultGroup(e)); + if ( e->is(Type::IfcStructuralSteelProfileProperties) ) return IfcSchemaEntity(new IfcStructuralSteelProfileProperties(e)); + if ( e->is(Type::IfcStructuralSurfaceConnection) ) return IfcSchemaEntity(new IfcStructuralSurfaceConnection(e)); + if ( e->is(Type::IfcStructuralSurfaceMember) ) return IfcSchemaEntity(new IfcStructuralSurfaceMember(e)); + if ( e->is(Type::IfcStructuralSurfaceMemberVarying) ) return IfcSchemaEntity(new IfcStructuralSurfaceMemberVarying(e)); + if ( e->is(Type::IfcStructuredDimensionCallout) ) return IfcSchemaEntity(new IfcStructuredDimensionCallout(e)); + if ( e->is(Type::IfcStyleModel) ) return IfcSchemaEntity(new IfcStyleModel(e)); + if ( e->is(Type::IfcStyledItem) ) return IfcSchemaEntity(new IfcStyledItem(e)); + if ( e->is(Type::IfcStyledRepresentation) ) return IfcSchemaEntity(new IfcStyledRepresentation(e)); + if ( e->is(Type::IfcSubContractResource) ) return IfcSchemaEntity(new IfcSubContractResource(e)); + if ( e->is(Type::IfcSubedge) ) return IfcSchemaEntity(new IfcSubedge(e)); + if ( e->is(Type::IfcSurface) ) return IfcSchemaEntity(new IfcSurface(e)); + if ( e->is(Type::IfcSurfaceCurveSweptAreaSolid) ) return IfcSchemaEntity(new IfcSurfaceCurveSweptAreaSolid(e)); + if ( e->is(Type::IfcSurfaceOfLinearExtrusion) ) return IfcSchemaEntity(new IfcSurfaceOfLinearExtrusion(e)); + if ( e->is(Type::IfcSurfaceOfRevolution) ) return IfcSchemaEntity(new IfcSurfaceOfRevolution(e)); + if ( e->is(Type::IfcSurfaceStyle) ) return IfcSchemaEntity(new IfcSurfaceStyle(e)); + if ( e->is(Type::IfcSurfaceStyleLighting) ) return IfcSchemaEntity(new IfcSurfaceStyleLighting(e)); + if ( e->is(Type::IfcSurfaceStyleRefraction) ) return IfcSchemaEntity(new IfcSurfaceStyleRefraction(e)); + if ( e->is(Type::IfcSurfaceStyleRendering) ) return IfcSchemaEntity(new IfcSurfaceStyleRendering(e)); + if ( e->is(Type::IfcSurfaceStyleShading) ) return IfcSchemaEntity(new IfcSurfaceStyleShading(e)); + if ( e->is(Type::IfcSurfaceStyleWithTextures) ) return IfcSchemaEntity(new IfcSurfaceStyleWithTextures(e)); + if ( e->is(Type::IfcSurfaceTexture) ) return IfcSchemaEntity(new IfcSurfaceTexture(e)); + if ( e->is(Type::IfcSweptAreaSolid) ) return IfcSchemaEntity(new IfcSweptAreaSolid(e)); + if ( e->is(Type::IfcSweptDiskSolid) ) return IfcSchemaEntity(new IfcSweptDiskSolid(e)); + if ( e->is(Type::IfcSweptSurface) ) return IfcSchemaEntity(new IfcSweptSurface(e)); + if ( e->is(Type::IfcSwitchingDeviceType) ) return IfcSchemaEntity(new IfcSwitchingDeviceType(e)); + if ( e->is(Type::IfcSymbolStyle) ) return IfcSchemaEntity(new IfcSymbolStyle(e)); + if ( e->is(Type::IfcSystem) ) return IfcSchemaEntity(new IfcSystem(e)); + if ( e->is(Type::IfcSystemFurnitureElementType) ) return IfcSchemaEntity(new IfcSystemFurnitureElementType(e)); + if ( e->is(Type::IfcTShapeProfileDef) ) return IfcSchemaEntity(new IfcTShapeProfileDef(e)); + if ( e->is(Type::IfcTable) ) return IfcSchemaEntity(new IfcTable(e)); + if ( e->is(Type::IfcTableRow) ) return IfcSchemaEntity(new IfcTableRow(e)); + if ( e->is(Type::IfcTankType) ) return IfcSchemaEntity(new IfcTankType(e)); + if ( e->is(Type::IfcTask) ) return IfcSchemaEntity(new IfcTask(e)); + if ( e->is(Type::IfcTelecomAddress) ) return IfcSchemaEntity(new IfcTelecomAddress(e)); + if ( e->is(Type::IfcTendon) ) return IfcSchemaEntity(new IfcTendon(e)); + if ( e->is(Type::IfcTendonAnchor) ) return IfcSchemaEntity(new IfcTendonAnchor(e)); + if ( e->is(Type::IfcTerminatorSymbol) ) return IfcSchemaEntity(new IfcTerminatorSymbol(e)); + if ( e->is(Type::IfcTextLiteral) ) return IfcSchemaEntity(new IfcTextLiteral(e)); + if ( e->is(Type::IfcTextLiteralWithExtent) ) return IfcSchemaEntity(new IfcTextLiteralWithExtent(e)); + if ( e->is(Type::IfcTextStyle) ) return IfcSchemaEntity(new IfcTextStyle(e)); + if ( e->is(Type::IfcTextStyleFontModel) ) return IfcSchemaEntity(new IfcTextStyleFontModel(e)); + if ( e->is(Type::IfcTextStyleForDefinedFont) ) return IfcSchemaEntity(new IfcTextStyleForDefinedFont(e)); + if ( e->is(Type::IfcTextStyleTextModel) ) return IfcSchemaEntity(new IfcTextStyleTextModel(e)); + if ( e->is(Type::IfcTextStyleWithBoxCharacteristics) ) return IfcSchemaEntity(new IfcTextStyleWithBoxCharacteristics(e)); + if ( e->is(Type::IfcTextureCoordinate) ) return IfcSchemaEntity(new IfcTextureCoordinate(e)); + if ( e->is(Type::IfcTextureCoordinateGenerator) ) return IfcSchemaEntity(new IfcTextureCoordinateGenerator(e)); + if ( e->is(Type::IfcTextureMap) ) return IfcSchemaEntity(new IfcTextureMap(e)); + if ( e->is(Type::IfcTextureVertex) ) return IfcSchemaEntity(new IfcTextureVertex(e)); + if ( e->is(Type::IfcThermalMaterialProperties) ) return IfcSchemaEntity(new IfcThermalMaterialProperties(e)); + if ( e->is(Type::IfcTimeSeries) ) return IfcSchemaEntity(new IfcTimeSeries(e)); + if ( e->is(Type::IfcTimeSeriesReferenceRelationship) ) return IfcSchemaEntity(new IfcTimeSeriesReferenceRelationship(e)); + if ( e->is(Type::IfcTimeSeriesSchedule) ) return IfcSchemaEntity(new IfcTimeSeriesSchedule(e)); + if ( e->is(Type::IfcTimeSeriesValue) ) return IfcSchemaEntity(new IfcTimeSeriesValue(e)); + if ( e->is(Type::IfcTopologicalRepresentationItem) ) return IfcSchemaEntity(new IfcTopologicalRepresentationItem(e)); + if ( e->is(Type::IfcTopologyRepresentation) ) return IfcSchemaEntity(new IfcTopologyRepresentation(e)); + if ( e->is(Type::IfcTransformerType) ) return IfcSchemaEntity(new IfcTransformerType(e)); + if ( e->is(Type::IfcTransportElement) ) return IfcSchemaEntity(new IfcTransportElement(e)); + if ( e->is(Type::IfcTransportElementType) ) return IfcSchemaEntity(new IfcTransportElementType(e)); + if ( e->is(Type::IfcTrapeziumProfileDef) ) return IfcSchemaEntity(new IfcTrapeziumProfileDef(e)); + if ( e->is(Type::IfcTrimmedCurve) ) return IfcSchemaEntity(new IfcTrimmedCurve(e)); + if ( e->is(Type::IfcTubeBundleType) ) return IfcSchemaEntity(new IfcTubeBundleType(e)); + if ( e->is(Type::IfcTwoDirectionRepeatFactor) ) return IfcSchemaEntity(new IfcTwoDirectionRepeatFactor(e)); + if ( e->is(Type::IfcTypeObject) ) return IfcSchemaEntity(new IfcTypeObject(e)); + if ( e->is(Type::IfcTypeProduct) ) return IfcSchemaEntity(new IfcTypeProduct(e)); + if ( e->is(Type::IfcUShapeProfileDef) ) return IfcSchemaEntity(new IfcUShapeProfileDef(e)); + if ( e->is(Type::IfcUnitAssignment) ) return IfcSchemaEntity(new IfcUnitAssignment(e)); + if ( e->is(Type::IfcUnitaryEquipmentType) ) return IfcSchemaEntity(new IfcUnitaryEquipmentType(e)); + if ( e->is(Type::IfcValveType) ) return IfcSchemaEntity(new IfcValveType(e)); + if ( e->is(Type::IfcVector) ) return IfcSchemaEntity(new IfcVector(e)); + if ( e->is(Type::IfcVertex) ) return IfcSchemaEntity(new IfcVertex(e)); + if ( e->is(Type::IfcVertexBasedTextureMap) ) return IfcSchemaEntity(new IfcVertexBasedTextureMap(e)); + if ( e->is(Type::IfcVertexLoop) ) return IfcSchemaEntity(new IfcVertexLoop(e)); + if ( e->is(Type::IfcVertexPoint) ) return IfcSchemaEntity(new IfcVertexPoint(e)); + if ( e->is(Type::IfcVibrationIsolatorType) ) return IfcSchemaEntity(new IfcVibrationIsolatorType(e)); + if ( e->is(Type::IfcVirtualElement) ) return IfcSchemaEntity(new IfcVirtualElement(e)); + if ( e->is(Type::IfcVirtualGridIntersection) ) return IfcSchemaEntity(new IfcVirtualGridIntersection(e)); + if ( e->is(Type::IfcWall) ) return IfcSchemaEntity(new IfcWall(e)); + if ( e->is(Type::IfcWallStandardCase) ) return IfcSchemaEntity(new IfcWallStandardCase(e)); + if ( e->is(Type::IfcWallType) ) return IfcSchemaEntity(new IfcWallType(e)); + if ( e->is(Type::IfcWasteTerminalType) ) return IfcSchemaEntity(new IfcWasteTerminalType(e)); + if ( e->is(Type::IfcWaterProperties) ) return IfcSchemaEntity(new IfcWaterProperties(e)); + if ( e->is(Type::IfcWindow) ) return IfcSchemaEntity(new IfcWindow(e)); + if ( e->is(Type::IfcWindowLiningProperties) ) return IfcSchemaEntity(new IfcWindowLiningProperties(e)); + if ( e->is(Type::IfcWindowPanelProperties) ) return IfcSchemaEntity(new IfcWindowPanelProperties(e)); + if ( e->is(Type::IfcWindowStyle) ) return IfcSchemaEntity(new IfcWindowStyle(e)); + if ( e->is(Type::IfcWorkControl) ) return IfcSchemaEntity(new IfcWorkControl(e)); + if ( e->is(Type::IfcWorkPlan) ) return IfcSchemaEntity(new IfcWorkPlan(e)); + if ( e->is(Type::IfcWorkSchedule) ) return IfcSchemaEntity(new IfcWorkSchedule(e)); + if ( e->is(Type::IfcZShapeProfileDef) ) return IfcSchemaEntity(new IfcZShapeProfileDef(e)); + if ( e->is(Type::IfcZone) ) return IfcSchemaEntity(new IfcZone(e)); + throw; +} + +std::string Type::ToString(Enum v) { + if (v < 0 || v >= 759) throw; + const char* names[] = { "IfcSoundPowerMeasure","IfcRotationalFrequencyMeasure","IfcSpecificHeatCapacityMeasure","IfcElectricConductanceMeasure","IfcElectricChargeMeasure","IfcPositiveLengthMeasure","IfcAngularVelocityMeasure","IfcNullStyle","IfcIonConcentrationMeasure","IfcModulusOfLinearSubgradeReactionMeasure","IfcHeatFluxDensityMeasure","IfcHeatingValueMeasure","IfcForceMeasure","IfcPositiveRatioMeasure","IfcMolecularWeightMeasure","IfcLuminousFluxMeasure","IfcNormalisedRatioMeasure","IfcLabel","IfcTimeStamp","IfcNumericMeasure","IfcRotationalMassMeasure","IfcLinearForceMeasure","IfcKinematicViscosityMeasure","IfcMassDensityMeasure","IfcIntegerCountRateMeasure","IfcRadioActivityMeasure","IfcReal","IfcLinearMomentMeasure","IfcElectricCurrentMeasure","IfcThermalTransmittanceMeasure","IfcModulusOfElasticityMeasure","IfcInductanceMeasure","IfcWarpingMomentMeasure","IfcDynamicViscosityMeasure","IfcAreaMeasure","IfcLogical","IfcAmountOfSubstanceMeasure","IfcContextDependentMeasure","IfcThermalConductivityMeasure","IfcEnergyMeasure","IfcRotationalStiffnessMeasure","IfcDerivedMeasureValue","IfcPowerMeasure","IfcThermalExpansionCoefficientMeasure","IfcTorqueMeasure","IfcMassPerLengthMeasure","IfcCountMeasure","IfcCurveStyleFontSelect","IfcVolumetricFlowRateMeasure","IfcModulusOfSubgradeReactionMeasure","IfcMassFlowRateMeasure","IfcMonetaryMeasure","IfcTemperatureGradientMeasure","IfcColour","IfcVolumeMeasure","IfcSectionalAreaIntegralMeasure","IfcVaporPermeabilityMeasure","IfcLinearVelocityMeasure","IfcLengthMeasure","IfcModulusOfRotationalSubgradeReactionMeasure","IfcPlanarForceMeasure","IfcInteger","IfcSimpleValue","IfcMeasureValue","IfcPlaneAngleMeasure","IfcWarpingConstantMeasure","IfcElectricCapacitanceMeasure","IfcSoundPressureMeasure","IfcSpecularRoughness","IfcIlluminanceMeasure","IfcText","IfcTimeMeasure","IfcAccelerationMeasure","IfcLuminousIntensityMeasure","IfcPressureMeasure","IfcElectricVoltageMeasure","IfcThermodynamicTemperatureMeasure","IfcMagneticFluxMeasure","IfcSolidAngleMeasure","IfcFrequencyMeasure","IfcPHMeasure","IfcThermalAdmittanceMeasure","IfcSpecularExponent","IfcDateTimeSelect","IfcLinearStiffnessMeasure","IfcCompoundPlaneAngleMeasure","IfcCurvatureMeasure","IfcAbsorbedDoseMeasure","IfcParameterValue","IfcDescriptiveMeasure","IfcMomentOfInertiaMeasure","IfcDoseEquivalentMeasure","IfcComplexNumber","IfcRatioMeasure","IfcLuminousIntensityDistributionMeasure","IfcIsothermalMoistureCapacityMeasure","IfcElectricResistanceMeasure","IfcThermalResistanceMeasure","IfcShearModulusMeasure","IfcIdentifier","IfcBoolean","IfcSectionModulusMeasure","IfcMassMeasure","IfcMoistureDiffusivityMeasure","IfcPositivePlaneAngleMeasure","IfcMagneticFluxDensityMeasure","Ifc2DCompositeCurve","IfcActionRequest","IfcActor","IfcActorRole","IfcActuatorType","IfcAddress","IfcAirTerminalBoxType","IfcAirTerminalType","IfcAirToAirHeatRecoveryType","IfcAlarmType","IfcAngularDimension","IfcAnnotation","IfcAnnotationCurveOccurrence","IfcAnnotationFillArea","IfcAnnotationFillAreaOccurrence","IfcAnnotationOccurrence","IfcAnnotationSurface","IfcAnnotationSurfaceOccurrence","IfcAnnotationSymbolOccurrence","IfcAnnotationTextOccurrence","IfcApplication","IfcAppliedValue","IfcAppliedValueRelationship","IfcApproval","IfcApprovalActorRelationship","IfcApprovalPropertyRelationship","IfcApprovalRelationship","IfcArbitraryClosedProfileDef","IfcArbitraryOpenProfileDef","IfcArbitraryProfileDefWithVoids","IfcAsset","IfcAsymmetricIShapeProfileDef","IfcAxis1Placement","IfcAxis2Placement2D","IfcAxis2Placement3D","IfcBSplineCurve","IfcBeam","IfcBeamType","IfcBezierCurve","IfcBlobTexture","IfcBlock","IfcBoilerType","IfcBooleanClippingResult","IfcBooleanResult","IfcBoundaryCondition","IfcBoundaryEdgeCondition","IfcBoundaryFaceCondition","IfcBoundaryNodeCondition","IfcBoundaryNodeConditionWarping","IfcBoundedCurve","IfcBoundedSurface","IfcBoundingBox","IfcBoxedHalfSpace","IfcBuilding","IfcBuildingElement","IfcBuildingElementComponent","IfcBuildingElementPart","IfcBuildingElementProxy","IfcBuildingElementProxyType","IfcBuildingElementType","IfcBuildingStorey","IfcCShapeProfileDef","IfcCableCarrierFittingType","IfcCableCarrierSegmentType","IfcCableSegmentType","IfcCalendarDate","IfcCartesianPoint","IfcCartesianTransformationOperator","IfcCartesianTransformationOperator2D","IfcCartesianTransformationOperator2DnonUniform","IfcCartesianTransformationOperator3D","IfcCartesianTransformationOperator3DnonUniform","IfcCenterLineProfileDef","IfcChamferEdgeFeature","IfcChillerType","IfcCircle","IfcCircleHollowProfileDef","IfcCircleProfileDef","IfcClassification","IfcClassificationItem","IfcClassificationItemRelationship","IfcClassificationNotation","IfcClassificationNotationFacet","IfcClassificationReference","IfcClosedShell","IfcCoilType","IfcColourRgb","IfcColourSpecification","IfcColumn","IfcColumnType","IfcComplexProperty","IfcCompositeCurve","IfcCompositeCurveSegment","IfcCompositeProfileDef","IfcCompressorType","IfcCondenserType","IfcCondition","IfcConditionCriterion","IfcConic","IfcConnectedFaceSet","IfcConnectionCurveGeometry","IfcConnectionGeometry","IfcConnectionPointEccentricity","IfcConnectionPointGeometry","IfcConnectionPortGeometry","IfcConnectionSurfaceGeometry","IfcConstraint","IfcConstraintAggregationRelationship","IfcConstraintClassificationRelationship","IfcConstraintRelationship","IfcConstructionEquipmentResource","IfcConstructionMaterialResource","IfcConstructionProductResource","IfcConstructionResource","IfcContextDependentUnit","IfcControl","IfcControllerType","IfcConversionBasedUnit","IfcCooledBeamType","IfcCoolingTowerType","IfcCoordinatedUniversalTimeOffset","IfcCostItem","IfcCostSchedule","IfcCostValue","IfcCovering","IfcCoveringType","IfcCraneRailAShapeProfileDef","IfcCraneRailFShapeProfileDef","IfcCrewResource","IfcCsgPrimitive3D","IfcCsgSolid","IfcCurrencyRelationship","IfcCurtainWall","IfcCurtainWallType","IfcCurve","IfcCurveBoundedPlane","IfcCurveStyle","IfcCurveStyleFont","IfcCurveStyleFontAndScaling","IfcCurveStyleFontPattern","IfcDamperType","IfcDateAndTime","IfcDefinedSymbol","IfcDerivedProfileDef","IfcDerivedUnit","IfcDerivedUnitElement","IfcDiameterDimension","IfcDimensionCalloutRelationship","IfcDimensionCurve","IfcDimensionCurveDirectedCallout","IfcDimensionCurveTerminator","IfcDimensionPair","IfcDimensionalExponents","IfcDirection","IfcDiscreteAccessory","IfcDiscreteAccessoryType","IfcDistributionChamberElement","IfcDistributionChamberElementType","IfcDistributionControlElement","IfcDistributionControlElementType","IfcDistributionElement","IfcDistributionElementType","IfcDistributionFlowElement","IfcDistributionFlowElementType","IfcDistributionPort","IfcDocumentElectronicFormat","IfcDocumentInformation","IfcDocumentInformationRelationship","IfcDocumentReference","IfcDoor","IfcDoorLiningProperties","IfcDoorPanelProperties","IfcDoorStyle","IfcDraughtingCallout","IfcDraughtingCalloutRelationship","IfcDraughtingPreDefinedColour","IfcDraughtingPreDefinedCurveFont","IfcDraughtingPreDefinedTextFont","IfcDuctFittingType","IfcDuctSegmentType","IfcDuctSilencerType","IfcEdge","IfcEdgeCurve","IfcEdgeFeature","IfcEdgeLoop","IfcElectricApplianceType","IfcElectricDistributionPoint","IfcElectricFlowStorageDeviceType","IfcElectricGeneratorType","IfcElectricHeaterType","IfcElectricMotorType","IfcElectricTimeControlType","IfcElectricalBaseProperties","IfcElectricalCircuit","IfcElectricalElement","IfcElement","IfcElementAssembly","IfcElementComponent","IfcElementComponentType","IfcElementQuantity","IfcElementType","IfcElementarySurface","IfcEllipse","IfcEllipseProfileDef","IfcEnergyConversionDevice","IfcEnergyConversionDeviceType","IfcEnergyProperties","IfcEnvironmentalImpactValue","IfcEquipmentElement","IfcEquipmentStandard","IfcEvaporativeCoolerType","IfcEvaporatorType","IfcExtendedMaterialProperties","IfcExternalReference","IfcExternallyDefinedHatchStyle","IfcExternallyDefinedSurfaceStyle","IfcExternallyDefinedSymbol","IfcExternallyDefinedTextFont","IfcExtrudedAreaSolid","IfcFace","IfcFaceBasedSurfaceModel","IfcFaceBound","IfcFaceOuterBound","IfcFaceSurface","IfcFacetedBrep","IfcFacetedBrepWithVoids","IfcFailureConnectionCondition","IfcFanType","IfcFastener","IfcFastenerType","IfcFeatureElement","IfcFeatureElementAddition","IfcFeatureElementSubtraction","IfcFillAreaStyle","IfcFillAreaStyleHatching","IfcFillAreaStyleTileSymbolWithStyle","IfcFillAreaStyleTiles","IfcFilterType","IfcFireSuppressionTerminalType","IfcFlowController","IfcFlowControllerType","IfcFlowFitting","IfcFlowFittingType","IfcFlowInstrumentType","IfcFlowMeterType","IfcFlowMovingDevice","IfcFlowMovingDeviceType","IfcFlowSegment","IfcFlowSegmentType","IfcFlowStorageDevice","IfcFlowStorageDeviceType","IfcFlowTerminal","IfcFlowTerminalType","IfcFlowTreatmentDevice","IfcFlowTreatmentDeviceType","IfcFluidFlowProperties","IfcFooting","IfcFuelProperties","IfcFurnishingElement","IfcFurnishingElementType","IfcFurnitureStandard","IfcFurnitureType","IfcGasTerminalType","IfcGeneralMaterialProperties","IfcGeneralProfileProperties","IfcGeometricCurveSet","IfcGeometricRepresentationContext","IfcGeometricRepresentationItem","IfcGeometricRepresentationSubContext","IfcGeometricSet","IfcGrid","IfcGridAxis","IfcGridPlacement","IfcGroup","IfcHalfSpaceSolid","IfcHeatExchangerType","IfcHumidifierType","IfcHygroscopicMaterialProperties","IfcIShapeProfileDef","IfcImageTexture","IfcInventory","IfcIrregularTimeSeries","IfcIrregularTimeSeriesValue","IfcJunctionBoxType","IfcLShapeProfileDef","IfcLaborResource","IfcLampType","IfcLibraryInformation","IfcLibraryReference","IfcLightDistributionData","IfcLightFixtureType","IfcLightIntensityDistribution","IfcLightSource","IfcLightSourceAmbient","IfcLightSourceDirectional","IfcLightSourceGoniometric","IfcLightSourcePositional","IfcLightSourceSpot","IfcLine","IfcLinearDimension","IfcLocalPlacement","IfcLocalTime","IfcLoop","IfcManifoldSolidBrep","IfcMappedItem","IfcMaterial","IfcMaterialClassificationRelationship","IfcMaterialDefinitionRepresentation","IfcMaterialLayer","IfcMaterialLayerSet","IfcMaterialLayerSetUsage","IfcMaterialList","IfcMaterialProperties","IfcMeasureWithUnit","IfcMechanicalConcreteMaterialProperties","IfcMechanicalFastener","IfcMechanicalFastenerType","IfcMechanicalMaterialProperties","IfcMechanicalSteelMaterialProperties","IfcMember","IfcMemberType","IfcMetric","IfcMonetaryUnit","IfcMotorConnectionType","IfcMove","IfcNamedUnit","IfcObject","IfcObjectDefinition","IfcObjectPlacement","IfcObjective","IfcOccupant","IfcOffsetCurve2D","IfcOffsetCurve3D","IfcOneDirectionRepeatFactor","IfcOpenShell","IfcOpeningElement","IfcOpticalMaterialProperties","IfcOrderAction","IfcOrganization","IfcOrganizationRelationship","IfcOrientedEdge","IfcOutletType","IfcOwnerHistory","IfcParameterizedProfileDef","IfcPath","IfcPerformanceHistory","IfcPermeableCoveringProperties","IfcPermit","IfcPerson","IfcPersonAndOrganization","IfcPhysicalComplexQuantity","IfcPhysicalQuantity","IfcPhysicalSimpleQuantity","IfcPile","IfcPipeFittingType","IfcPipeSegmentType","IfcPixelTexture","IfcPlacement","IfcPlanarBox","IfcPlanarExtent","IfcPlane","IfcPlate","IfcPlateType","IfcPoint","IfcPointOnCurve","IfcPointOnSurface","IfcPolyLoop","IfcPolygonalBoundedHalfSpace","IfcPolyline","IfcPort","IfcPostalAddress","IfcPreDefinedColour","IfcPreDefinedCurveFont","IfcPreDefinedDimensionSymbol","IfcPreDefinedItem","IfcPreDefinedPointMarkerSymbol","IfcPreDefinedSymbol","IfcPreDefinedTerminatorSymbol","IfcPreDefinedTextFont","IfcPresentationLayerAssignment","IfcPresentationLayerWithStyle","IfcPresentationStyle","IfcPresentationStyleAssignment","IfcProcedure","IfcProcess","IfcProduct","IfcProductDefinitionShape","IfcProductRepresentation","IfcProductsOfCombustionProperties","IfcProfileDef","IfcProfileProperties","IfcProject","IfcProjectOrder","IfcProjectOrderRecord","IfcProjectionCurve","IfcProjectionElement","IfcProperty","IfcPropertyBoundedValue","IfcPropertyConstraintRelationship","IfcPropertyDefinition","IfcPropertyDependencyRelationship","IfcPropertyEnumeratedValue","IfcPropertyEnumeration","IfcPropertyListValue","IfcPropertyReferenceValue","IfcPropertySet","IfcPropertySetDefinition","IfcPropertySingleValue","IfcPropertyTableValue","IfcProtectiveDeviceType","IfcProxy","IfcPumpType","IfcQuantityArea","IfcQuantityCount","IfcQuantityLength","IfcQuantityTime","IfcQuantityVolume","IfcQuantityWeight","IfcRadiusDimension","IfcRailing","IfcRailingType","IfcRamp","IfcRampFlight","IfcRampFlightType","IfcRationalBezierCurve","IfcRectangleHollowProfileDef","IfcRectangleProfileDef","IfcRectangularPyramid","IfcRectangularTrimmedSurface","IfcReferencesValueDocument","IfcRegularTimeSeries","IfcReinforcementBarProperties","IfcReinforcementDefinitionProperties","IfcReinforcingBar","IfcReinforcingElement","IfcReinforcingMesh","IfcRelAggregates","IfcRelAssigns","IfcRelAssignsTasks","IfcRelAssignsToActor","IfcRelAssignsToControl","IfcRelAssignsToGroup","IfcRelAssignsToProcess","IfcRelAssignsToProduct","IfcRelAssignsToProjectOrder","IfcRelAssignsToResource","IfcRelAssociates","IfcRelAssociatesAppliedValue","IfcRelAssociatesApproval","IfcRelAssociatesClassification","IfcRelAssociatesConstraint","IfcRelAssociatesDocument","IfcRelAssociatesLibrary","IfcRelAssociatesMaterial","IfcRelAssociatesProfileProperties","IfcRelConnects","IfcRelConnectsElements","IfcRelConnectsPathElements","IfcRelConnectsPortToElement","IfcRelConnectsPorts","IfcRelConnectsStructuralActivity","IfcRelConnectsStructuralElement","IfcRelConnectsStructuralMember","IfcRelConnectsWithEccentricity","IfcRelConnectsWithRealizingElements","IfcRelContainedInSpatialStructure","IfcRelCoversBldgElements","IfcRelCoversSpaces","IfcRelDecomposes","IfcRelDefines","IfcRelDefinesByProperties","IfcRelDefinesByType","IfcRelFillsElement","IfcRelFlowControlElements","IfcRelInteractionRequirements","IfcRelNests","IfcRelOccupiesSpaces","IfcRelOverridesProperties","IfcRelProjectsElement","IfcRelReferencedInSpatialStructure","IfcRelSchedulesCostItems","IfcRelSequence","IfcRelServicesBuildings","IfcRelSpaceBoundary","IfcRelVoidsElement","IfcRelationship","IfcRelaxation","IfcRepresentation","IfcRepresentationContext","IfcRepresentationItem","IfcRepresentationMap","IfcResource","IfcRevolvedAreaSolid","IfcRibPlateProfileProperties","IfcRightCircularCone","IfcRightCircularCylinder","IfcRoof","IfcRoot","IfcRoundedEdgeFeature","IfcRoundedRectangleProfileDef","IfcSIUnit","IfcSanitaryTerminalType","IfcScheduleTimeControl","IfcSectionProperties","IfcSectionReinforcementProperties","IfcSectionedSpine","IfcSensorType","IfcServiceLife","IfcServiceLifeFactor","IfcShapeAspect","IfcShapeModel","IfcShapeRepresentation","IfcShellBasedSurfaceModel","IfcSimpleProperty","IfcSite","IfcSlab","IfcSlabType","IfcSlippageConnectionCondition","IfcSolidModel","IfcSoundProperties","IfcSoundValue","IfcSpace","IfcSpaceHeaterType","IfcSpaceProgram","IfcSpaceThermalLoadProperties","IfcSpaceType","IfcSpatialStructureElement","IfcSpatialStructureElementType","IfcSphere","IfcStackTerminalType","IfcStair","IfcStairFlight","IfcStairFlightType","IfcStructuralAction","IfcStructuralActivity","IfcStructuralAnalysisModel","IfcStructuralConnection","IfcStructuralConnectionCondition","IfcStructuralCurveConnection","IfcStructuralCurveMember","IfcStructuralCurveMemberVarying","IfcStructuralItem","IfcStructuralLinearAction","IfcStructuralLinearActionVarying","IfcStructuralLoad","IfcStructuralLoadGroup","IfcStructuralLoadLinearForce","IfcStructuralLoadPlanarForce","IfcStructuralLoadSingleDisplacement","IfcStructuralLoadSingleDisplacementDistortion","IfcStructuralLoadSingleForce","IfcStructuralLoadSingleForceWarping","IfcStructuralLoadStatic","IfcStructuralLoadTemperature","IfcStructuralMember","IfcStructuralPlanarAction","IfcStructuralPlanarActionVarying","IfcStructuralPointAction","IfcStructuralPointConnection","IfcStructuralPointReaction","IfcStructuralProfileProperties","IfcStructuralReaction","IfcStructuralResultGroup","IfcStructuralSteelProfileProperties","IfcStructuralSurfaceConnection","IfcStructuralSurfaceMember","IfcStructuralSurfaceMemberVarying","IfcStructuredDimensionCallout","IfcStyleModel","IfcStyledItem","IfcStyledRepresentation","IfcSubContractResource","IfcSubedge","IfcSurface","IfcSurfaceCurveSweptAreaSolid","IfcSurfaceOfLinearExtrusion","IfcSurfaceOfRevolution","IfcSurfaceStyle","IfcSurfaceStyleLighting","IfcSurfaceStyleRefraction","IfcSurfaceStyleRendering","IfcSurfaceStyleShading","IfcSurfaceStyleWithTextures","IfcSurfaceTexture","IfcSweptAreaSolid","IfcSweptDiskSolid","IfcSweptSurface","IfcSwitchingDeviceType","IfcSymbolStyle","IfcSystem","IfcSystemFurnitureElementType","IfcTShapeProfileDef","IfcTable","IfcTableRow","IfcTankType","IfcTask","IfcTelecomAddress","IfcTendon","IfcTendonAnchor","IfcTerminatorSymbol","IfcTextLiteral","IfcTextLiteralWithExtent","IfcTextStyle","IfcTextStyleFontModel","IfcTextStyleForDefinedFont","IfcTextStyleTextModel","IfcTextStyleWithBoxCharacteristics","IfcTextureCoordinate","IfcTextureCoordinateGenerator","IfcTextureMap","IfcTextureVertex","IfcThermalMaterialProperties","IfcTimeSeries","IfcTimeSeriesReferenceRelationship","IfcTimeSeriesSchedule","IfcTimeSeriesValue","IfcTopologicalRepresentationItem","IfcTopologyRepresentation","IfcTransformerType","IfcTransportElement","IfcTransportElementType","IfcTrapeziumProfileDef","IfcTrimmedCurve","IfcTubeBundleType","IfcTwoDirectionRepeatFactor","IfcTypeObject","IfcTypeProduct","IfcUShapeProfileDef","IfcUnitAssignment","IfcUnitaryEquipmentType","IfcValveType","IfcVector","IfcVertex","IfcVertexBasedTextureMap","IfcVertexLoop","IfcVertexPoint","IfcVibrationIsolatorType","IfcVirtualElement","IfcVirtualGridIntersection","IfcWall","IfcWallStandardCase","IfcWallType","IfcWasteTerminalType","IfcWaterProperties","IfcWindow","IfcWindowLiningProperties","IfcWindowPanelProperties","IfcWindowStyle","IfcWorkControl","IfcWorkPlan","IfcWorkSchedule","IfcZShapeProfileDef","IfcZone" }; + return names[v]; +} + +Type::Enum Type::FromString(const std::string& s){ + if(s=="IFCSOUNDPOWERMEASURE" ) { return IfcSoundPowerMeasure; } + if(s=="IFCROTATIONALFREQUENCYMEASURE" ) { return IfcRotationalFrequencyMeasure; } + if(s=="IFCSPECIFICHEATCAPACITYMEASURE" ) { return IfcSpecificHeatCapacityMeasure; } + if(s=="IFCELECTRICCONDUCTANCEMEASURE" ) { return IfcElectricConductanceMeasure; } + if(s=="IFCELECTRICCHARGEMEASURE" ) { return IfcElectricChargeMeasure; } + if(s=="IFCPOSITIVELENGTHMEASURE" ) { return IfcPositiveLengthMeasure; } + if(s=="IFCANGULARVELOCITYMEASURE" ) { return IfcAngularVelocityMeasure; } + if(s=="IFCNULLSTYLE" ) { return IfcNullStyle; } + if(s=="IFCIONCONCENTRATIONMEASURE" ) { return IfcIonConcentrationMeasure; } + if(s=="IFCMODULUSOFLINEARSUBGRADEREACTIONMEASURE" ) { return IfcModulusOfLinearSubgradeReactionMeasure; } + if(s=="IFCHEATFLUXDENSITYMEASURE" ) { return IfcHeatFluxDensityMeasure; } + if(s=="IFCHEATINGVALUEMEASURE" ) { return IfcHeatingValueMeasure; } + if(s=="IFCFORCEMEASURE" ) { return IfcForceMeasure; } + if(s=="IFCPOSITIVERATIOMEASURE" ) { return IfcPositiveRatioMeasure; } + if(s=="IFCMOLECULARWEIGHTMEASURE" ) { return IfcMolecularWeightMeasure; } + if(s=="IFCLUMINOUSFLUXMEASURE" ) { return IfcLuminousFluxMeasure; } + if(s=="IFCNORMALISEDRATIOMEASURE" ) { return IfcNormalisedRatioMeasure; } + if(s=="IFCLABEL" ) { return IfcLabel; } + if(s=="IFCTIMESTAMP" ) { return IfcTimeStamp; } + if(s=="IFCNUMERICMEASURE" ) { return IfcNumericMeasure; } + if(s=="IFCROTATIONALMASSMEASURE" ) { return IfcRotationalMassMeasure; } + if(s=="IFCLINEARFORCEMEASURE" ) { return IfcLinearForceMeasure; } + if(s=="IFCKINEMATICVISCOSITYMEASURE" ) { return IfcKinematicViscosityMeasure; } + if(s=="IFCMASSDENSITYMEASURE" ) { return IfcMassDensityMeasure; } + if(s=="IFCINTEGERCOUNTRATEMEASURE" ) { return IfcIntegerCountRateMeasure; } + if(s=="IFCRADIOACTIVITYMEASURE" ) { return IfcRadioActivityMeasure; } + if(s=="IFCREAL" ) { return IfcReal; } + if(s=="IFCLINEARMOMENTMEASURE" ) { return IfcLinearMomentMeasure; } + if(s=="IFCELECTRICCURRENTMEASURE" ) { return IfcElectricCurrentMeasure; } + if(s=="IFCTHERMALTRANSMITTANCEMEASURE" ) { return IfcThermalTransmittanceMeasure; } + if(s=="IFCMODULUSOFELASTICITYMEASURE" ) { return IfcModulusOfElasticityMeasure; } + if(s=="IFCINDUCTANCEMEASURE" ) { return IfcInductanceMeasure; } + if(s=="IFCWARPINGMOMENTMEASURE" ) { return IfcWarpingMomentMeasure; } + if(s=="IFCDYNAMICVISCOSITYMEASURE" ) { return IfcDynamicViscosityMeasure; } + if(s=="IFCAREAMEASURE" ) { return IfcAreaMeasure; } + if(s=="IFCLOGICAL" ) { return IfcLogical; } + if(s=="IFCAMOUNTOFSUBSTANCEMEASURE" ) { return IfcAmountOfSubstanceMeasure; } + if(s=="IFCCONTEXTDEPENDENTMEASURE" ) { return IfcContextDependentMeasure; } + if(s=="IFCTHERMALCONDUCTIVITYMEASURE" ) { return IfcThermalConductivityMeasure; } + if(s=="IFCENERGYMEASURE" ) { return IfcEnergyMeasure; } + if(s=="IFCROTATIONALSTIFFNESSMEASURE" ) { return IfcRotationalStiffnessMeasure; } + if(s=="IFCDERIVEDMEASUREVALUE" ) { return IfcDerivedMeasureValue; } + if(s=="IFCPOWERMEASURE" ) { return IfcPowerMeasure; } + if(s=="IFCTHERMALEXPANSIONCOEFFICIENTMEASURE" ) { return IfcThermalExpansionCoefficientMeasure; } + if(s=="IFCTORQUEMEASURE" ) { return IfcTorqueMeasure; } + if(s=="IFCMASSPERLENGTHMEASURE" ) { return IfcMassPerLengthMeasure; } + if(s=="IFCCOUNTMEASURE" ) { return IfcCountMeasure; } + if(s=="IFCCURVESTYLEFONTSELECT" ) { return IfcCurveStyleFontSelect; } + if(s=="IFCVOLUMETRICFLOWRATEMEASURE" ) { return IfcVolumetricFlowRateMeasure; } + if(s=="IFCMODULUSOFSUBGRADEREACTIONMEASURE" ) { return IfcModulusOfSubgradeReactionMeasure; } + if(s=="IFCMASSFLOWRATEMEASURE" ) { return IfcMassFlowRateMeasure; } + if(s=="IFCMONETARYMEASURE" ) { return IfcMonetaryMeasure; } + if(s=="IFCTEMPERATUREGRADIENTMEASURE" ) { return IfcTemperatureGradientMeasure; } + if(s=="IFCCOLOUR" ) { return IfcColour; } + if(s=="IFCVOLUMEMEASURE" ) { return IfcVolumeMeasure; } + if(s=="IFCSECTIONALAREAINTEGRALMEASURE" ) { return IfcSectionalAreaIntegralMeasure; } + if(s=="IFCVAPORPERMEABILITYMEASURE" ) { return IfcVaporPermeabilityMeasure; } + if(s=="IFCLINEARVELOCITYMEASURE" ) { return IfcLinearVelocityMeasure; } + if(s=="IFCLENGTHMEASURE" ) { return IfcLengthMeasure; } + if(s=="IFCMODULUSOFROTATIONALSUBGRADEREACTIONMEASURE" ) { return IfcModulusOfRotationalSubgradeReactionMeasure; } + if(s=="IFCPLANARFORCEMEASURE" ) { return IfcPlanarForceMeasure; } + if(s=="IFCINTEGER" ) { return IfcInteger; } + if(s=="IFCSIMPLEVALUE" ) { return IfcSimpleValue; } + if(s=="IFCMEASUREVALUE" ) { return IfcMeasureValue; } + if(s=="IFCPLANEANGLEMEASURE" ) { return IfcPlaneAngleMeasure; } + if(s=="IFCWARPINGCONSTANTMEASURE" ) { return IfcWarpingConstantMeasure; } + if(s=="IFCELECTRICCAPACITANCEMEASURE" ) { return IfcElectricCapacitanceMeasure; } + if(s=="IFCSOUNDPRESSUREMEASURE" ) { return IfcSoundPressureMeasure; } + if(s=="IFCSPECULARROUGHNESS" ) { return IfcSpecularRoughness; } + if(s=="IFCILLUMINANCEMEASURE" ) { return IfcIlluminanceMeasure; } + if(s=="IFCTEXT" ) { return IfcText; } + if(s=="IFCTIMEMEASURE" ) { return IfcTimeMeasure; } + if(s=="IFCACCELERATIONMEASURE" ) { return IfcAccelerationMeasure; } + if(s=="IFCLUMINOUSINTENSITYMEASURE" ) { return IfcLuminousIntensityMeasure; } + if(s=="IFCPRESSUREMEASURE" ) { return IfcPressureMeasure; } + if(s=="IFCELECTRICVOLTAGEMEASURE" ) { return IfcElectricVoltageMeasure; } + if(s=="IFCTHERMODYNAMICTEMPERATUREMEASURE" ) { return IfcThermodynamicTemperatureMeasure; } + if(s=="IFCMAGNETICFLUXMEASURE" ) { return IfcMagneticFluxMeasure; } + if(s=="IFCSOLIDANGLEMEASURE" ) { return IfcSolidAngleMeasure; } + if(s=="IFCFREQUENCYMEASURE" ) { return IfcFrequencyMeasure; } + if(s=="IFCPHMEASURE" ) { return IfcPHMeasure; } + if(s=="IFCTHERMALADMITTANCEMEASURE" ) { return IfcThermalAdmittanceMeasure; } + if(s=="IFCSPECULAREXPONENT" ) { return IfcSpecularExponent; } + if(s=="IFCDATETIMESELECT" ) { return IfcDateTimeSelect; } + if(s=="IFCLINEARSTIFFNESSMEASURE" ) { return IfcLinearStiffnessMeasure; } + if(s=="IFCCOMPOUNDPLANEANGLEMEASURE" ) { return IfcCompoundPlaneAngleMeasure; } + if(s=="IFCCURVATUREMEASURE" ) { return IfcCurvatureMeasure; } + if(s=="IFCABSORBEDDOSEMEASURE" ) { return IfcAbsorbedDoseMeasure; } + if(s=="IFCPARAMETERVALUE" ) { return IfcParameterValue; } + if(s=="IFCDESCRIPTIVEMEASURE" ) { return IfcDescriptiveMeasure; } + if(s=="IFCMOMENTOFINERTIAMEASURE" ) { return IfcMomentOfInertiaMeasure; } + if(s=="IFCDOSEEQUIVALENTMEASURE" ) { return IfcDoseEquivalentMeasure; } + if(s=="IFCCOMPLEXNUMBER" ) { return IfcComplexNumber; } + if(s=="IFCRATIOMEASURE" ) { return IfcRatioMeasure; } + if(s=="IFCLUMINOUSINTENSITYDISTRIBUTIONMEASURE" ) { return IfcLuminousIntensityDistributionMeasure; } + if(s=="IFCISOTHERMALMOISTURECAPACITYMEASURE" ) { return IfcIsothermalMoistureCapacityMeasure; } + if(s=="IFCELECTRICRESISTANCEMEASURE" ) { return IfcElectricResistanceMeasure; } + if(s=="IFCTHERMALRESISTANCEMEASURE" ) { return IfcThermalResistanceMeasure; } + if(s=="IFCSHEARMODULUSMEASURE" ) { return IfcShearModulusMeasure; } + if(s=="IFCIDENTIFIER" ) { return IfcIdentifier; } + if(s=="IFCBOOLEAN" ) { return IfcBoolean; } + if(s=="IFCSECTIONMODULUSMEASURE" ) { return IfcSectionModulusMeasure; } + if(s=="IFCMASSMEASURE" ) { return IfcMassMeasure; } + if(s=="IFCMOISTUREDIFFUSIVITYMEASURE" ) { return IfcMoistureDiffusivityMeasure; } + if(s=="IFCPOSITIVEPLANEANGLEMEASURE" ) { return IfcPositivePlaneAngleMeasure; } + if(s=="IFCMAGNETICFLUXDENSITYMEASURE" ) { return IfcMagneticFluxDensityMeasure; } + if(s=="IFC2DCOMPOSITECURVE" ) { return Ifc2DCompositeCurve; } + if(s=="IFCACTIONREQUEST" ) { return IfcActionRequest; } + if(s=="IFCACTOR" ) { return IfcActor; } + if(s=="IFCACTORROLE" ) { return IfcActorRole; } + if(s=="IFCACTUATORTYPE" ) { return IfcActuatorType; } + if(s=="IFCADDRESS" ) { return IfcAddress; } + if(s=="IFCAIRTERMINALBOXTYPE" ) { return IfcAirTerminalBoxType; } + if(s=="IFCAIRTERMINALTYPE" ) { return IfcAirTerminalType; } + if(s=="IFCAIRTOAIRHEATRECOVERYTYPE" ) { return IfcAirToAirHeatRecoveryType; } + if(s=="IFCALARMTYPE" ) { return IfcAlarmType; } + if(s=="IFCANGULARDIMENSION" ) { return IfcAngularDimension; } + if(s=="IFCANNOTATION" ) { return IfcAnnotation; } + if(s=="IFCANNOTATIONCURVEOCCURRENCE" ) { return IfcAnnotationCurveOccurrence; } + if(s=="IFCANNOTATIONFILLAREA" ) { return IfcAnnotationFillArea; } + if(s=="IFCANNOTATIONFILLAREAOCCURRENCE" ) { return IfcAnnotationFillAreaOccurrence; } + if(s=="IFCANNOTATIONOCCURRENCE" ) { return IfcAnnotationOccurrence; } + if(s=="IFCANNOTATIONSURFACE" ) { return IfcAnnotationSurface; } + if(s=="IFCANNOTATIONSURFACEOCCURRENCE" ) { return IfcAnnotationSurfaceOccurrence; } + if(s=="IFCANNOTATIONSYMBOLOCCURRENCE" ) { return IfcAnnotationSymbolOccurrence; } + if(s=="IFCANNOTATIONTEXTOCCURRENCE" ) { return IfcAnnotationTextOccurrence; } + if(s=="IFCAPPLICATION" ) { return IfcApplication; } + if(s=="IFCAPPLIEDVALUE" ) { return IfcAppliedValue; } + if(s=="IFCAPPLIEDVALUERELATIONSHIP" ) { return IfcAppliedValueRelationship; } + if(s=="IFCAPPROVAL" ) { return IfcApproval; } + if(s=="IFCAPPROVALACTORRELATIONSHIP" ) { return IfcApprovalActorRelationship; } + if(s=="IFCAPPROVALPROPERTYRELATIONSHIP" ) { return IfcApprovalPropertyRelationship; } + if(s=="IFCAPPROVALRELATIONSHIP" ) { return IfcApprovalRelationship; } + if(s=="IFCARBITRARYCLOSEDPROFILEDEF" ) { return IfcArbitraryClosedProfileDef; } + if(s=="IFCARBITRARYOPENPROFILEDEF" ) { return IfcArbitraryOpenProfileDef; } + if(s=="IFCARBITRARYPROFILEDEFWITHVOIDS" ) { return IfcArbitraryProfileDefWithVoids; } + if(s=="IFCASSET" ) { return IfcAsset; } + if(s=="IFCASYMMETRICISHAPEPROFILEDEF" ) { return IfcAsymmetricIShapeProfileDef; } + if(s=="IFCAXIS1PLACEMENT" ) { return IfcAxis1Placement; } + if(s=="IFCAXIS2PLACEMENT2D" ) { return IfcAxis2Placement2D; } + if(s=="IFCAXIS2PLACEMENT3D" ) { return IfcAxis2Placement3D; } + if(s=="IFCBSPLINECURVE" ) { return IfcBSplineCurve; } + if(s=="IFCBEAM" ) { return IfcBeam; } + if(s=="IFCBEAMTYPE" ) { return IfcBeamType; } + if(s=="IFCBEZIERCURVE" ) { return IfcBezierCurve; } + if(s=="IFCBLOBTEXTURE" ) { return IfcBlobTexture; } + if(s=="IFCBLOCK" ) { return IfcBlock; } + if(s=="IFCBOILERTYPE" ) { return IfcBoilerType; } + if(s=="IFCBOOLEANCLIPPINGRESULT" ) { return IfcBooleanClippingResult; } + if(s=="IFCBOOLEANRESULT" ) { return IfcBooleanResult; } + if(s=="IFCBOUNDARYCONDITION" ) { return IfcBoundaryCondition; } + if(s=="IFCBOUNDARYEDGECONDITION" ) { return IfcBoundaryEdgeCondition; } + if(s=="IFCBOUNDARYFACECONDITION" ) { return IfcBoundaryFaceCondition; } + if(s=="IFCBOUNDARYNODECONDITION" ) { return IfcBoundaryNodeCondition; } + if(s=="IFCBOUNDARYNODECONDITIONWARPING" ) { return IfcBoundaryNodeConditionWarping; } + if(s=="IFCBOUNDEDCURVE" ) { return IfcBoundedCurve; } + if(s=="IFCBOUNDEDSURFACE" ) { return IfcBoundedSurface; } + if(s=="IFCBOUNDINGBOX" ) { return IfcBoundingBox; } + if(s=="IFCBOXEDHALFSPACE" ) { return IfcBoxedHalfSpace; } + if(s=="IFCBUILDING" ) { return IfcBuilding; } + if(s=="IFCBUILDINGELEMENT" ) { return IfcBuildingElement; } + if(s=="IFCBUILDINGELEMENTCOMPONENT" ) { return IfcBuildingElementComponent; } + if(s=="IFCBUILDINGELEMENTPART" ) { return IfcBuildingElementPart; } + if(s=="IFCBUILDINGELEMENTPROXY" ) { return IfcBuildingElementProxy; } + if(s=="IFCBUILDINGELEMENTPROXYTYPE" ) { return IfcBuildingElementProxyType; } + if(s=="IFCBUILDINGELEMENTTYPE" ) { return IfcBuildingElementType; } + if(s=="IFCBUILDINGSTOREY" ) { return IfcBuildingStorey; } + if(s=="IFCCSHAPEPROFILEDEF" ) { return IfcCShapeProfileDef; } + if(s=="IFCCABLECARRIERFITTINGTYPE" ) { return IfcCableCarrierFittingType; } + if(s=="IFCCABLECARRIERSEGMENTTYPE" ) { return IfcCableCarrierSegmentType; } + if(s=="IFCCABLESEGMENTTYPE" ) { return IfcCableSegmentType; } + if(s=="IFCCALENDARDATE" ) { return IfcCalendarDate; } + if(s=="IFCCARTESIANPOINT" ) { return IfcCartesianPoint; } + if(s=="IFCCARTESIANTRANSFORMATIONOPERATOR" ) { return IfcCartesianTransformationOperator; } + if(s=="IFCCARTESIANTRANSFORMATIONOPERATOR2D" ) { return IfcCartesianTransformationOperator2D; } + if(s=="IFCCARTESIANTRANSFORMATIONOPERATOR2DNONUNIFORM") { return IfcCartesianTransformationOperator2DnonUniform; } + if(s=="IFCCARTESIANTRANSFORMATIONOPERATOR3D" ) { return IfcCartesianTransformationOperator3D; } + if(s=="IFCCARTESIANTRANSFORMATIONOPERATOR3DNONUNIFORM") { return IfcCartesianTransformationOperator3DnonUniform; } + if(s=="IFCCENTERLINEPROFILEDEF" ) { return IfcCenterLineProfileDef; } + if(s=="IFCCHAMFEREDGEFEATURE" ) { return IfcChamferEdgeFeature; } + if(s=="IFCCHILLERTYPE" ) { return IfcChillerType; } + if(s=="IFCCIRCLE" ) { return IfcCircle; } + if(s=="IFCCIRCLEHOLLOWPROFILEDEF" ) { return IfcCircleHollowProfileDef; } + if(s=="IFCCIRCLEPROFILEDEF" ) { return IfcCircleProfileDef; } + if(s=="IFCCLASSIFICATION" ) { return IfcClassification; } + if(s=="IFCCLASSIFICATIONITEM" ) { return IfcClassificationItem; } + if(s=="IFCCLASSIFICATIONITEMRELATIONSHIP" ) { return IfcClassificationItemRelationship; } + if(s=="IFCCLASSIFICATIONNOTATION" ) { return IfcClassificationNotation; } + if(s=="IFCCLASSIFICATIONNOTATIONFACET" ) { return IfcClassificationNotationFacet; } + if(s=="IFCCLASSIFICATIONREFERENCE" ) { return IfcClassificationReference; } + if(s=="IFCCLOSEDSHELL" ) { return IfcClosedShell; } + if(s=="IFCCOILTYPE" ) { return IfcCoilType; } + if(s=="IFCCOLOURRGB" ) { return IfcColourRgb; } + if(s=="IFCCOLOURSPECIFICATION" ) { return IfcColourSpecification; } + if(s=="IFCCOLUMN" ) { return IfcColumn; } + if(s=="IFCCOLUMNTYPE" ) { return IfcColumnType; } + if(s=="IFCCOMPLEXPROPERTY" ) { return IfcComplexProperty; } + if(s=="IFCCOMPOSITECURVE" ) { return IfcCompositeCurve; } + if(s=="IFCCOMPOSITECURVESEGMENT" ) { return IfcCompositeCurveSegment; } + if(s=="IFCCOMPOSITEPROFILEDEF" ) { return IfcCompositeProfileDef; } + if(s=="IFCCOMPRESSORTYPE" ) { return IfcCompressorType; } + if(s=="IFCCONDENSERTYPE" ) { return IfcCondenserType; } + if(s=="IFCCONDITION" ) { return IfcCondition; } + if(s=="IFCCONDITIONCRITERION" ) { return IfcConditionCriterion; } + if(s=="IFCCONIC" ) { return IfcConic; } + if(s=="IFCCONNECTEDFACESET" ) { return IfcConnectedFaceSet; } + if(s=="IFCCONNECTIONCURVEGEOMETRY" ) { return IfcConnectionCurveGeometry; } + if(s=="IFCCONNECTIONGEOMETRY" ) { return IfcConnectionGeometry; } + if(s=="IFCCONNECTIONPOINTECCENTRICITY" ) { return IfcConnectionPointEccentricity; } + if(s=="IFCCONNECTIONPOINTGEOMETRY" ) { return IfcConnectionPointGeometry; } + if(s=="IFCCONNECTIONPORTGEOMETRY" ) { return IfcConnectionPortGeometry; } + if(s=="IFCCONNECTIONSURFACEGEOMETRY" ) { return IfcConnectionSurfaceGeometry; } + if(s=="IFCCONSTRAINT" ) { return IfcConstraint; } + if(s=="IFCCONSTRAINTAGGREGATIONRELATIONSHIP" ) { return IfcConstraintAggregationRelationship; } + if(s=="IFCCONSTRAINTCLASSIFICATIONRELATIONSHIP" ) { return IfcConstraintClassificationRelationship; } + if(s=="IFCCONSTRAINTRELATIONSHIP" ) { return IfcConstraintRelationship; } + if(s=="IFCCONSTRUCTIONEQUIPMENTRESOURCE" ) { return IfcConstructionEquipmentResource; } + if(s=="IFCCONSTRUCTIONMATERIALRESOURCE" ) { return IfcConstructionMaterialResource; } + if(s=="IFCCONSTRUCTIONPRODUCTRESOURCE" ) { return IfcConstructionProductResource; } + if(s=="IFCCONSTRUCTIONRESOURCE" ) { return IfcConstructionResource; } + if(s=="IFCCONTEXTDEPENDENTUNIT" ) { return IfcContextDependentUnit; } + if(s=="IFCCONTROL" ) { return IfcControl; } + if(s=="IFCCONTROLLERTYPE" ) { return IfcControllerType; } + if(s=="IFCCONVERSIONBASEDUNIT" ) { return IfcConversionBasedUnit; } + if(s=="IFCCOOLEDBEAMTYPE" ) { return IfcCooledBeamType; } + if(s=="IFCCOOLINGTOWERTYPE" ) { return IfcCoolingTowerType; } + if(s=="IFCCOORDINATEDUNIVERSALTIMEOFFSET" ) { return IfcCoordinatedUniversalTimeOffset; } + if(s=="IFCCOSTITEM" ) { return IfcCostItem; } + if(s=="IFCCOSTSCHEDULE" ) { return IfcCostSchedule; } + if(s=="IFCCOSTVALUE" ) { return IfcCostValue; } + if(s=="IFCCOVERING" ) { return IfcCovering; } + if(s=="IFCCOVERINGTYPE" ) { return IfcCoveringType; } + if(s=="IFCCRANERAILASHAPEPROFILEDEF" ) { return IfcCraneRailAShapeProfileDef; } + if(s=="IFCCRANERAILFSHAPEPROFILEDEF" ) { return IfcCraneRailFShapeProfileDef; } + if(s=="IFCCREWRESOURCE" ) { return IfcCrewResource; } + if(s=="IFCCSGPRIMITIVE3D" ) { return IfcCsgPrimitive3D; } + if(s=="IFCCSGSOLID" ) { return IfcCsgSolid; } + if(s=="IFCCURRENCYRELATIONSHIP" ) { return IfcCurrencyRelationship; } + if(s=="IFCCURTAINWALL" ) { return IfcCurtainWall; } + if(s=="IFCCURTAINWALLTYPE" ) { return IfcCurtainWallType; } + if(s=="IFCCURVE" ) { return IfcCurve; } + if(s=="IFCCURVEBOUNDEDPLANE" ) { return IfcCurveBoundedPlane; } + if(s=="IFCCURVESTYLE" ) { return IfcCurveStyle; } + if(s=="IFCCURVESTYLEFONT" ) { return IfcCurveStyleFont; } + if(s=="IFCCURVESTYLEFONTANDSCALING" ) { return IfcCurveStyleFontAndScaling; } + if(s=="IFCCURVESTYLEFONTPATTERN" ) { return IfcCurveStyleFontPattern; } + if(s=="IFCDAMPERTYPE" ) { return IfcDamperType; } + if(s=="IFCDATEANDTIME" ) { return IfcDateAndTime; } + if(s=="IFCDEFINEDSYMBOL" ) { return IfcDefinedSymbol; } + if(s=="IFCDERIVEDPROFILEDEF" ) { return IfcDerivedProfileDef; } + if(s=="IFCDERIVEDUNIT" ) { return IfcDerivedUnit; } + if(s=="IFCDERIVEDUNITELEMENT" ) { return IfcDerivedUnitElement; } + if(s=="IFCDIAMETERDIMENSION" ) { return IfcDiameterDimension; } + if(s=="IFCDIMENSIONCALLOUTRELATIONSHIP" ) { return IfcDimensionCalloutRelationship; } + if(s=="IFCDIMENSIONCURVE" ) { return IfcDimensionCurve; } + if(s=="IFCDIMENSIONCURVEDIRECTEDCALLOUT" ) { return IfcDimensionCurveDirectedCallout; } + if(s=="IFCDIMENSIONCURVETERMINATOR" ) { return IfcDimensionCurveTerminator; } + if(s=="IFCDIMENSIONPAIR" ) { return IfcDimensionPair; } + if(s=="IFCDIMENSIONALEXPONENTS" ) { return IfcDimensionalExponents; } + if(s=="IFCDIRECTION" ) { return IfcDirection; } + if(s=="IFCDISCRETEACCESSORY" ) { return IfcDiscreteAccessory; } + if(s=="IFCDISCRETEACCESSORYTYPE" ) { return IfcDiscreteAccessoryType; } + if(s=="IFCDISTRIBUTIONCHAMBERELEMENT" ) { return IfcDistributionChamberElement; } + if(s=="IFCDISTRIBUTIONCHAMBERELEMENTTYPE" ) { return IfcDistributionChamberElementType; } + if(s=="IFCDISTRIBUTIONCONTROLELEMENT" ) { return IfcDistributionControlElement; } + if(s=="IFCDISTRIBUTIONCONTROLELEMENTTYPE" ) { return IfcDistributionControlElementType; } + if(s=="IFCDISTRIBUTIONELEMENT" ) { return IfcDistributionElement; } + if(s=="IFCDISTRIBUTIONELEMENTTYPE" ) { return IfcDistributionElementType; } + if(s=="IFCDISTRIBUTIONFLOWELEMENT" ) { return IfcDistributionFlowElement; } + if(s=="IFCDISTRIBUTIONFLOWELEMENTTYPE" ) { return IfcDistributionFlowElementType; } + if(s=="IFCDISTRIBUTIONPORT" ) { return IfcDistributionPort; } + if(s=="IFCDOCUMENTELECTRONICFORMAT" ) { return IfcDocumentElectronicFormat; } + if(s=="IFCDOCUMENTINFORMATION" ) { return IfcDocumentInformation; } + if(s=="IFCDOCUMENTINFORMATIONRELATIONSHIP" ) { return IfcDocumentInformationRelationship; } + if(s=="IFCDOCUMENTREFERENCE" ) { return IfcDocumentReference; } + if(s=="IFCDOOR" ) { return IfcDoor; } + if(s=="IFCDOORLININGPROPERTIES" ) { return IfcDoorLiningProperties; } + if(s=="IFCDOORPANELPROPERTIES" ) { return IfcDoorPanelProperties; } + if(s=="IFCDOORSTYLE" ) { return IfcDoorStyle; } + if(s=="IFCDRAUGHTINGCALLOUT" ) { return IfcDraughtingCallout; } + if(s=="IFCDRAUGHTINGCALLOUTRELATIONSHIP" ) { return IfcDraughtingCalloutRelationship; } + if(s=="IFCDRAUGHTINGPREDEFINEDCOLOUR" ) { return IfcDraughtingPreDefinedColour; } + if(s=="IFCDRAUGHTINGPREDEFINEDCURVEFONT" ) { return IfcDraughtingPreDefinedCurveFont; } + if(s=="IFCDRAUGHTINGPREDEFINEDTEXTFONT" ) { return IfcDraughtingPreDefinedTextFont; } + if(s=="IFCDUCTFITTINGTYPE" ) { return IfcDuctFittingType; } + if(s=="IFCDUCTSEGMENTTYPE" ) { return IfcDuctSegmentType; } + if(s=="IFCDUCTSILENCERTYPE" ) { return IfcDuctSilencerType; } + if(s=="IFCEDGE" ) { return IfcEdge; } + if(s=="IFCEDGECURVE" ) { return IfcEdgeCurve; } + if(s=="IFCEDGEFEATURE" ) { return IfcEdgeFeature; } + if(s=="IFCEDGELOOP" ) { return IfcEdgeLoop; } + if(s=="IFCELECTRICAPPLIANCETYPE" ) { return IfcElectricApplianceType; } + if(s=="IFCELECTRICDISTRIBUTIONPOINT" ) { return IfcElectricDistributionPoint; } + if(s=="IFCELECTRICFLOWSTORAGEDEVICETYPE" ) { return IfcElectricFlowStorageDeviceType; } + if(s=="IFCELECTRICGENERATORTYPE" ) { return IfcElectricGeneratorType; } + if(s=="IFCELECTRICHEATERTYPE" ) { return IfcElectricHeaterType; } + if(s=="IFCELECTRICMOTORTYPE" ) { return IfcElectricMotorType; } + if(s=="IFCELECTRICTIMECONTROLTYPE" ) { return IfcElectricTimeControlType; } + if(s=="IFCELECTRICALBASEPROPERTIES" ) { return IfcElectricalBaseProperties; } + if(s=="IFCELECTRICALCIRCUIT" ) { return IfcElectricalCircuit; } + if(s=="IFCELECTRICALELEMENT" ) { return IfcElectricalElement; } + if(s=="IFCELEMENT" ) { return IfcElement; } + if(s=="IFCELEMENTASSEMBLY" ) { return IfcElementAssembly; } + if(s=="IFCELEMENTCOMPONENT" ) { return IfcElementComponent; } + if(s=="IFCELEMENTCOMPONENTTYPE" ) { return IfcElementComponentType; } + if(s=="IFCELEMENTQUANTITY" ) { return IfcElementQuantity; } + if(s=="IFCELEMENTTYPE" ) { return IfcElementType; } + if(s=="IFCELEMENTARYSURFACE" ) { return IfcElementarySurface; } + if(s=="IFCELLIPSE" ) { return IfcEllipse; } + if(s=="IFCELLIPSEPROFILEDEF" ) { return IfcEllipseProfileDef; } + if(s=="IFCENERGYCONVERSIONDEVICE" ) { return IfcEnergyConversionDevice; } + if(s=="IFCENERGYCONVERSIONDEVICETYPE" ) { return IfcEnergyConversionDeviceType; } + if(s=="IFCENERGYPROPERTIES" ) { return IfcEnergyProperties; } + if(s=="IFCENVIRONMENTALIMPACTVALUE" ) { return IfcEnvironmentalImpactValue; } + if(s=="IFCEQUIPMENTELEMENT" ) { return IfcEquipmentElement; } + if(s=="IFCEQUIPMENTSTANDARD" ) { return IfcEquipmentStandard; } + if(s=="IFCEVAPORATIVECOOLERTYPE" ) { return IfcEvaporativeCoolerType; } + if(s=="IFCEVAPORATORTYPE" ) { return IfcEvaporatorType; } + if(s=="IFCEXTENDEDMATERIALPROPERTIES" ) { return IfcExtendedMaterialProperties; } + if(s=="IFCEXTERNALREFERENCE" ) { return IfcExternalReference; } + if(s=="IFCEXTERNALLYDEFINEDHATCHSTYLE" ) { return IfcExternallyDefinedHatchStyle; } + if(s=="IFCEXTERNALLYDEFINEDSURFACESTYLE" ) { return IfcExternallyDefinedSurfaceStyle; } + if(s=="IFCEXTERNALLYDEFINEDSYMBOL" ) { return IfcExternallyDefinedSymbol; } + if(s=="IFCEXTERNALLYDEFINEDTEXTFONT" ) { return IfcExternallyDefinedTextFont; } + if(s=="IFCEXTRUDEDAREASOLID" ) { return IfcExtrudedAreaSolid; } + if(s=="IFCFACE" ) { return IfcFace; } + if(s=="IFCFACEBASEDSURFACEMODEL" ) { return IfcFaceBasedSurfaceModel; } + if(s=="IFCFACEBOUND" ) { return IfcFaceBound; } + if(s=="IFCFACEOUTERBOUND" ) { return IfcFaceOuterBound; } + if(s=="IFCFACESURFACE" ) { return IfcFaceSurface; } + if(s=="IFCFACETEDBREP" ) { return IfcFacetedBrep; } + if(s=="IFCFACETEDBREPWITHVOIDS" ) { return IfcFacetedBrepWithVoids; } + if(s=="IFCFAILURECONNECTIONCONDITION" ) { return IfcFailureConnectionCondition; } + if(s=="IFCFANTYPE" ) { return IfcFanType; } + if(s=="IFCFASTENER" ) { return IfcFastener; } + if(s=="IFCFASTENERTYPE" ) { return IfcFastenerType; } + if(s=="IFCFEATUREELEMENT" ) { return IfcFeatureElement; } + if(s=="IFCFEATUREELEMENTADDITION" ) { return IfcFeatureElementAddition; } + if(s=="IFCFEATUREELEMENTSUBTRACTION" ) { return IfcFeatureElementSubtraction; } + if(s=="IFCFILLAREASTYLE" ) { return IfcFillAreaStyle; } + if(s=="IFCFILLAREASTYLEHATCHING" ) { return IfcFillAreaStyleHatching; } + if(s=="IFCFILLAREASTYLETILESYMBOLWITHSTYLE" ) { return IfcFillAreaStyleTileSymbolWithStyle; } + if(s=="IFCFILLAREASTYLETILES" ) { return IfcFillAreaStyleTiles; } + if(s=="IFCFILTERTYPE" ) { return IfcFilterType; } + if(s=="IFCFIRESUPPRESSIONTERMINALTYPE" ) { return IfcFireSuppressionTerminalType; } + if(s=="IFCFLOWCONTROLLER" ) { return IfcFlowController; } + if(s=="IFCFLOWCONTROLLERTYPE" ) { return IfcFlowControllerType; } + if(s=="IFCFLOWFITTING" ) { return IfcFlowFitting; } + if(s=="IFCFLOWFITTINGTYPE" ) { return IfcFlowFittingType; } + if(s=="IFCFLOWINSTRUMENTTYPE" ) { return IfcFlowInstrumentType; } + if(s=="IFCFLOWMETERTYPE" ) { return IfcFlowMeterType; } + if(s=="IFCFLOWMOVINGDEVICE" ) { return IfcFlowMovingDevice; } + if(s=="IFCFLOWMOVINGDEVICETYPE" ) { return IfcFlowMovingDeviceType; } + if(s=="IFCFLOWSEGMENT" ) { return IfcFlowSegment; } + if(s=="IFCFLOWSEGMENTTYPE" ) { return IfcFlowSegmentType; } + if(s=="IFCFLOWSTORAGEDEVICE" ) { return IfcFlowStorageDevice; } + if(s=="IFCFLOWSTORAGEDEVICETYPE" ) { return IfcFlowStorageDeviceType; } + if(s=="IFCFLOWTERMINAL" ) { return IfcFlowTerminal; } + if(s=="IFCFLOWTERMINALTYPE" ) { return IfcFlowTerminalType; } + if(s=="IFCFLOWTREATMENTDEVICE" ) { return IfcFlowTreatmentDevice; } + if(s=="IFCFLOWTREATMENTDEVICETYPE" ) { return IfcFlowTreatmentDeviceType; } + if(s=="IFCFLUIDFLOWPROPERTIES" ) { return IfcFluidFlowProperties; } + if(s=="IFCFOOTING" ) { return IfcFooting; } + if(s=="IFCFUELPROPERTIES" ) { return IfcFuelProperties; } + if(s=="IFCFURNISHINGELEMENT" ) { return IfcFurnishingElement; } + if(s=="IFCFURNISHINGELEMENTTYPE" ) { return IfcFurnishingElementType; } + if(s=="IFCFURNITURESTANDARD" ) { return IfcFurnitureStandard; } + if(s=="IFCFURNITURETYPE" ) { return IfcFurnitureType; } + if(s=="IFCGASTERMINALTYPE" ) { return IfcGasTerminalType; } + if(s=="IFCGENERALMATERIALPROPERTIES" ) { return IfcGeneralMaterialProperties; } + if(s=="IFCGENERALPROFILEPROPERTIES" ) { return IfcGeneralProfileProperties; } + if(s=="IFCGEOMETRICCURVESET" ) { return IfcGeometricCurveSet; } + if(s=="IFCGEOMETRICREPRESENTATIONCONTEXT" ) { return IfcGeometricRepresentationContext; } + if(s=="IFCGEOMETRICREPRESENTATIONITEM" ) { return IfcGeometricRepresentationItem; } + if(s=="IFCGEOMETRICREPRESENTATIONSUBCONTEXT" ) { return IfcGeometricRepresentationSubContext; } + if(s=="IFCGEOMETRICSET" ) { return IfcGeometricSet; } + if(s=="IFCGRID" ) { return IfcGrid; } + if(s=="IFCGRIDAXIS" ) { return IfcGridAxis; } + if(s=="IFCGRIDPLACEMENT" ) { return IfcGridPlacement; } + if(s=="IFCGROUP" ) { return IfcGroup; } + if(s=="IFCHALFSPACESOLID" ) { return IfcHalfSpaceSolid; } + if(s=="IFCHEATEXCHANGERTYPE" ) { return IfcHeatExchangerType; } + if(s=="IFCHUMIDIFIERTYPE" ) { return IfcHumidifierType; } + if(s=="IFCHYGROSCOPICMATERIALPROPERTIES" ) { return IfcHygroscopicMaterialProperties; } + if(s=="IFCISHAPEPROFILEDEF" ) { return IfcIShapeProfileDef; } + if(s=="IFCIMAGETEXTURE" ) { return IfcImageTexture; } + if(s=="IFCINVENTORY" ) { return IfcInventory; } + if(s=="IFCIRREGULARTIMESERIES" ) { return IfcIrregularTimeSeries; } + if(s=="IFCIRREGULARTIMESERIESVALUE" ) { return IfcIrregularTimeSeriesValue; } + if(s=="IFCJUNCTIONBOXTYPE" ) { return IfcJunctionBoxType; } + if(s=="IFCLSHAPEPROFILEDEF" ) { return IfcLShapeProfileDef; } + if(s=="IFCLABORRESOURCE" ) { return IfcLaborResource; } + if(s=="IFCLAMPTYPE" ) { return IfcLampType; } + if(s=="IFCLIBRARYINFORMATION" ) { return IfcLibraryInformation; } + if(s=="IFCLIBRARYREFERENCE" ) { return IfcLibraryReference; } + if(s=="IFCLIGHTDISTRIBUTIONDATA" ) { return IfcLightDistributionData; } + if(s=="IFCLIGHTFIXTURETYPE" ) { return IfcLightFixtureType; } + if(s=="IFCLIGHTINTENSITYDISTRIBUTION" ) { return IfcLightIntensityDistribution; } + if(s=="IFCLIGHTSOURCE" ) { return IfcLightSource; } + if(s=="IFCLIGHTSOURCEAMBIENT" ) { return IfcLightSourceAmbient; } + if(s=="IFCLIGHTSOURCEDIRECTIONAL" ) { return IfcLightSourceDirectional; } + if(s=="IFCLIGHTSOURCEGONIOMETRIC" ) { return IfcLightSourceGoniometric; } + if(s=="IFCLIGHTSOURCEPOSITIONAL" ) { return IfcLightSourcePositional; } + if(s=="IFCLIGHTSOURCESPOT" ) { return IfcLightSourceSpot; } + if(s=="IFCLINE" ) { return IfcLine; } + if(s=="IFCLINEARDIMENSION" ) { return IfcLinearDimension; } + if(s=="IFCLOCALPLACEMENT" ) { return IfcLocalPlacement; } + if(s=="IFCLOCALTIME" ) { return IfcLocalTime; } + if(s=="IFCLOOP" ) { return IfcLoop; } + if(s=="IFCMANIFOLDSOLIDBREP" ) { return IfcManifoldSolidBrep; } + if(s=="IFCMAPPEDITEM" ) { return IfcMappedItem; } + if(s=="IFCMATERIAL" ) { return IfcMaterial; } + if(s=="IFCMATERIALCLASSIFICATIONRELATIONSHIP" ) { return IfcMaterialClassificationRelationship; } + if(s=="IFCMATERIALDEFINITIONREPRESENTATION" ) { return IfcMaterialDefinitionRepresentation; } + if(s=="IFCMATERIALLAYER" ) { return IfcMaterialLayer; } + if(s=="IFCMATERIALLAYERSET" ) { return IfcMaterialLayerSet; } + if(s=="IFCMATERIALLAYERSETUSAGE" ) { return IfcMaterialLayerSetUsage; } + if(s=="IFCMATERIALLIST" ) { return IfcMaterialList; } + if(s=="IFCMATERIALPROPERTIES" ) { return IfcMaterialProperties; } + if(s=="IFCMEASUREWITHUNIT" ) { return IfcMeasureWithUnit; } + if(s=="IFCMECHANICALCONCRETEMATERIALPROPERTIES" ) { return IfcMechanicalConcreteMaterialProperties; } + if(s=="IFCMECHANICALFASTENER" ) { return IfcMechanicalFastener; } + if(s=="IFCMECHANICALFASTENERTYPE" ) { return IfcMechanicalFastenerType; } + if(s=="IFCMECHANICALMATERIALPROPERTIES" ) { return IfcMechanicalMaterialProperties; } + if(s=="IFCMECHANICALSTEELMATERIALPROPERTIES" ) { return IfcMechanicalSteelMaterialProperties; } + if(s=="IFCMEMBER" ) { return IfcMember; } + if(s=="IFCMEMBERTYPE" ) { return IfcMemberType; } + if(s=="IFCMETRIC" ) { return IfcMetric; } + if(s=="IFCMONETARYUNIT" ) { return IfcMonetaryUnit; } + if(s=="IFCMOTORCONNECTIONTYPE" ) { return IfcMotorConnectionType; } + if(s=="IFCMOVE" ) { return IfcMove; } + if(s=="IFCNAMEDUNIT" ) { return IfcNamedUnit; } + if(s=="IFCOBJECT" ) { return IfcObject; } + if(s=="IFCOBJECTDEFINITION" ) { return IfcObjectDefinition; } + if(s=="IFCOBJECTPLACEMENT" ) { return IfcObjectPlacement; } + if(s=="IFCOBJECTIVE" ) { return IfcObjective; } + if(s=="IFCOCCUPANT" ) { return IfcOccupant; } + if(s=="IFCOFFSETCURVE2D" ) { return IfcOffsetCurve2D; } + if(s=="IFCOFFSETCURVE3D" ) { return IfcOffsetCurve3D; } + if(s=="IFCONEDIRECTIONREPEATFACTOR" ) { return IfcOneDirectionRepeatFactor; } + if(s=="IFCOPENSHELL" ) { return IfcOpenShell; } + if(s=="IFCOPENINGELEMENT" ) { return IfcOpeningElement; } + if(s=="IFCOPTICALMATERIALPROPERTIES" ) { return IfcOpticalMaterialProperties; } + if(s=="IFCORDERACTION" ) { return IfcOrderAction; } + if(s=="IFCORGANIZATION" ) { return IfcOrganization; } + if(s=="IFCORGANIZATIONRELATIONSHIP" ) { return IfcOrganizationRelationship; } + if(s=="IFCORIENTEDEDGE" ) { return IfcOrientedEdge; } + if(s=="IFCOUTLETTYPE" ) { return IfcOutletType; } + if(s=="IFCOWNERHISTORY" ) { return IfcOwnerHistory; } + if(s=="IFCPARAMETERIZEDPROFILEDEF" ) { return IfcParameterizedProfileDef; } + if(s=="IFCPATH" ) { return IfcPath; } + if(s=="IFCPERFORMANCEHISTORY" ) { return IfcPerformanceHistory; } + if(s=="IFCPERMEABLECOVERINGPROPERTIES" ) { return IfcPermeableCoveringProperties; } + if(s=="IFCPERMIT" ) { return IfcPermit; } + if(s=="IFCPERSON" ) { return IfcPerson; } + if(s=="IFCPERSONANDORGANIZATION" ) { return IfcPersonAndOrganization; } + if(s=="IFCPHYSICALCOMPLEXQUANTITY" ) { return IfcPhysicalComplexQuantity; } + if(s=="IFCPHYSICALQUANTITY" ) { return IfcPhysicalQuantity; } + if(s=="IFCPHYSICALSIMPLEQUANTITY" ) { return IfcPhysicalSimpleQuantity; } + if(s=="IFCPILE" ) { return IfcPile; } + if(s=="IFCPIPEFITTINGTYPE" ) { return IfcPipeFittingType; } + if(s=="IFCPIPESEGMENTTYPE" ) { return IfcPipeSegmentType; } + if(s=="IFCPIXELTEXTURE" ) { return IfcPixelTexture; } + if(s=="IFCPLACEMENT" ) { return IfcPlacement; } + if(s=="IFCPLANARBOX" ) { return IfcPlanarBox; } + if(s=="IFCPLANAREXTENT" ) { return IfcPlanarExtent; } + if(s=="IFCPLANE" ) { return IfcPlane; } + if(s=="IFCPLATE" ) { return IfcPlate; } + if(s=="IFCPLATETYPE" ) { return IfcPlateType; } + if(s=="IFCPOINT" ) { return IfcPoint; } + if(s=="IFCPOINTONCURVE" ) { return IfcPointOnCurve; } + if(s=="IFCPOINTONSURFACE" ) { return IfcPointOnSurface; } + if(s=="IFCPOLYLOOP" ) { return IfcPolyLoop; } + if(s=="IFCPOLYGONALBOUNDEDHALFSPACE" ) { return IfcPolygonalBoundedHalfSpace; } + if(s=="IFCPOLYLINE" ) { return IfcPolyline; } + if(s=="IFCPORT" ) { return IfcPort; } + if(s=="IFCPOSTALADDRESS" ) { return IfcPostalAddress; } + if(s=="IFCPREDEFINEDCOLOUR" ) { return IfcPreDefinedColour; } + if(s=="IFCPREDEFINEDCURVEFONT" ) { return IfcPreDefinedCurveFont; } + if(s=="IFCPREDEFINEDDIMENSIONSYMBOL" ) { return IfcPreDefinedDimensionSymbol; } + if(s=="IFCPREDEFINEDITEM" ) { return IfcPreDefinedItem; } + if(s=="IFCPREDEFINEDPOINTMARKERSYMBOL" ) { return IfcPreDefinedPointMarkerSymbol; } + if(s=="IFCPREDEFINEDSYMBOL" ) { return IfcPreDefinedSymbol; } + if(s=="IFCPREDEFINEDTERMINATORSYMBOL" ) { return IfcPreDefinedTerminatorSymbol; } + if(s=="IFCPREDEFINEDTEXTFONT" ) { return IfcPreDefinedTextFont; } + if(s=="IFCPRESENTATIONLAYERASSIGNMENT" ) { return IfcPresentationLayerAssignment; } + if(s=="IFCPRESENTATIONLAYERWITHSTYLE" ) { return IfcPresentationLayerWithStyle; } + if(s=="IFCPRESENTATIONSTYLE" ) { return IfcPresentationStyle; } + if(s=="IFCPRESENTATIONSTYLEASSIGNMENT" ) { return IfcPresentationStyleAssignment; } + if(s=="IFCPROCEDURE" ) { return IfcProcedure; } + if(s=="IFCPROCESS" ) { return IfcProcess; } + if(s=="IFCPRODUCT" ) { return IfcProduct; } + if(s=="IFCPRODUCTDEFINITIONSHAPE" ) { return IfcProductDefinitionShape; } + if(s=="IFCPRODUCTREPRESENTATION" ) { return IfcProductRepresentation; } + if(s=="IFCPRODUCTSOFCOMBUSTIONPROPERTIES" ) { return IfcProductsOfCombustionProperties; } + if(s=="IFCPROFILEDEF" ) { return IfcProfileDef; } + if(s=="IFCPROFILEPROPERTIES" ) { return IfcProfileProperties; } + if(s=="IFCPROJECT" ) { return IfcProject; } + if(s=="IFCPROJECTORDER" ) { return IfcProjectOrder; } + if(s=="IFCPROJECTORDERRECORD" ) { return IfcProjectOrderRecord; } + if(s=="IFCPROJECTIONCURVE" ) { return IfcProjectionCurve; } + if(s=="IFCPROJECTIONELEMENT" ) { return IfcProjectionElement; } + if(s=="IFCPROPERTY" ) { return IfcProperty; } + if(s=="IFCPROPERTYBOUNDEDVALUE" ) { return IfcPropertyBoundedValue; } + if(s=="IFCPROPERTYCONSTRAINTRELATIONSHIP" ) { return IfcPropertyConstraintRelationship; } + if(s=="IFCPROPERTYDEFINITION" ) { return IfcPropertyDefinition; } + if(s=="IFCPROPERTYDEPENDENCYRELATIONSHIP" ) { return IfcPropertyDependencyRelationship; } + if(s=="IFCPROPERTYENUMERATEDVALUE" ) { return IfcPropertyEnumeratedValue; } + if(s=="IFCPROPERTYENUMERATION" ) { return IfcPropertyEnumeration; } + if(s=="IFCPROPERTYLISTVALUE" ) { return IfcPropertyListValue; } + if(s=="IFCPROPERTYREFERENCEVALUE" ) { return IfcPropertyReferenceValue; } + if(s=="IFCPROPERTYSET" ) { return IfcPropertySet; } + if(s=="IFCPROPERTYSETDEFINITION" ) { return IfcPropertySetDefinition; } + if(s=="IFCPROPERTYSINGLEVALUE" ) { return IfcPropertySingleValue; } + if(s=="IFCPROPERTYTABLEVALUE" ) { return IfcPropertyTableValue; } + if(s=="IFCPROTECTIVEDEVICETYPE" ) { return IfcProtectiveDeviceType; } + if(s=="IFCPROXY" ) { return IfcProxy; } + if(s=="IFCPUMPTYPE" ) { return IfcPumpType; } + if(s=="IFCQUANTITYAREA" ) { return IfcQuantityArea; } + if(s=="IFCQUANTITYCOUNT" ) { return IfcQuantityCount; } + if(s=="IFCQUANTITYLENGTH" ) { return IfcQuantityLength; } + if(s=="IFCQUANTITYTIME" ) { return IfcQuantityTime; } + if(s=="IFCQUANTITYVOLUME" ) { return IfcQuantityVolume; } + if(s=="IFCQUANTITYWEIGHT" ) { return IfcQuantityWeight; } + if(s=="IFCRADIUSDIMENSION" ) { return IfcRadiusDimension; } + if(s=="IFCRAILING" ) { return IfcRailing; } + if(s=="IFCRAILINGTYPE" ) { return IfcRailingType; } + if(s=="IFCRAMP" ) { return IfcRamp; } + if(s=="IFCRAMPFLIGHT" ) { return IfcRampFlight; } + if(s=="IFCRAMPFLIGHTTYPE" ) { return IfcRampFlightType; } + if(s=="IFCRATIONALBEZIERCURVE" ) { return IfcRationalBezierCurve; } + if(s=="IFCRECTANGLEHOLLOWPROFILEDEF" ) { return IfcRectangleHollowProfileDef; } + if(s=="IFCRECTANGLEPROFILEDEF" ) { return IfcRectangleProfileDef; } + if(s=="IFCRECTANGULARPYRAMID" ) { return IfcRectangularPyramid; } + if(s=="IFCRECTANGULARTRIMMEDSURFACE" ) { return IfcRectangularTrimmedSurface; } + if(s=="IFCREFERENCESVALUEDOCUMENT" ) { return IfcReferencesValueDocument; } + if(s=="IFCREGULARTIMESERIES" ) { return IfcRegularTimeSeries; } + if(s=="IFCREINFORCEMENTBARPROPERTIES" ) { return IfcReinforcementBarProperties; } + if(s=="IFCREINFORCEMENTDEFINITIONPROPERTIES" ) { return IfcReinforcementDefinitionProperties; } + if(s=="IFCREINFORCINGBAR" ) { return IfcReinforcingBar; } + if(s=="IFCREINFORCINGELEMENT" ) { return IfcReinforcingElement; } + if(s=="IFCREINFORCINGMESH" ) { return IfcReinforcingMesh; } + if(s=="IFCRELAGGREGATES" ) { return IfcRelAggregates; } + if(s=="IFCRELASSIGNS" ) { return IfcRelAssigns; } + if(s=="IFCRELASSIGNSTASKS" ) { return IfcRelAssignsTasks; } + if(s=="IFCRELASSIGNSTOACTOR" ) { return IfcRelAssignsToActor; } + if(s=="IFCRELASSIGNSTOCONTROL" ) { return IfcRelAssignsToControl; } + if(s=="IFCRELASSIGNSTOGROUP" ) { return IfcRelAssignsToGroup; } + if(s=="IFCRELASSIGNSTOPROCESS" ) { return IfcRelAssignsToProcess; } + if(s=="IFCRELASSIGNSTOPRODUCT" ) { return IfcRelAssignsToProduct; } + if(s=="IFCRELASSIGNSTOPROJECTORDER" ) { return IfcRelAssignsToProjectOrder; } + if(s=="IFCRELASSIGNSTORESOURCE" ) { return IfcRelAssignsToResource; } + if(s=="IFCRELASSOCIATES" ) { return IfcRelAssociates; } + if(s=="IFCRELASSOCIATESAPPLIEDVALUE" ) { return IfcRelAssociatesAppliedValue; } + if(s=="IFCRELASSOCIATESAPPROVAL" ) { return IfcRelAssociatesApproval; } + if(s=="IFCRELASSOCIATESCLASSIFICATION" ) { return IfcRelAssociatesClassification; } + if(s=="IFCRELASSOCIATESCONSTRAINT" ) { return IfcRelAssociatesConstraint; } + if(s=="IFCRELASSOCIATESDOCUMENT" ) { return IfcRelAssociatesDocument; } + if(s=="IFCRELASSOCIATESLIBRARY" ) { return IfcRelAssociatesLibrary; } + if(s=="IFCRELASSOCIATESMATERIAL" ) { return IfcRelAssociatesMaterial; } + if(s=="IFCRELASSOCIATESPROFILEPROPERTIES" ) { return IfcRelAssociatesProfileProperties; } + if(s=="IFCRELCONNECTS" ) { return IfcRelConnects; } + if(s=="IFCRELCONNECTSELEMENTS" ) { return IfcRelConnectsElements; } + if(s=="IFCRELCONNECTSPATHELEMENTS" ) { return IfcRelConnectsPathElements; } + if(s=="IFCRELCONNECTSPORTTOELEMENT" ) { return IfcRelConnectsPortToElement; } + if(s=="IFCRELCONNECTSPORTS" ) { return IfcRelConnectsPorts; } + if(s=="IFCRELCONNECTSSTRUCTURALACTIVITY" ) { return IfcRelConnectsStructuralActivity; } + if(s=="IFCRELCONNECTSSTRUCTURALELEMENT" ) { return IfcRelConnectsStructuralElement; } + if(s=="IFCRELCONNECTSSTRUCTURALMEMBER" ) { return IfcRelConnectsStructuralMember; } + if(s=="IFCRELCONNECTSWITHECCENTRICITY" ) { return IfcRelConnectsWithEccentricity; } + if(s=="IFCRELCONNECTSWITHREALIZINGELEMENTS" ) { return IfcRelConnectsWithRealizingElements; } + if(s=="IFCRELCONTAINEDINSPATIALSTRUCTURE" ) { return IfcRelContainedInSpatialStructure; } + if(s=="IFCRELCOVERSBLDGELEMENTS" ) { return IfcRelCoversBldgElements; } + if(s=="IFCRELCOVERSSPACES" ) { return IfcRelCoversSpaces; } + if(s=="IFCRELDECOMPOSES" ) { return IfcRelDecomposes; } + if(s=="IFCRELDEFINES" ) { return IfcRelDefines; } + if(s=="IFCRELDEFINESBYPROPERTIES" ) { return IfcRelDefinesByProperties; } + if(s=="IFCRELDEFINESBYTYPE" ) { return IfcRelDefinesByType; } + if(s=="IFCRELFILLSELEMENT" ) { return IfcRelFillsElement; } + if(s=="IFCRELFLOWCONTROLELEMENTS" ) { return IfcRelFlowControlElements; } + if(s=="IFCRELINTERACTIONREQUIREMENTS" ) { return IfcRelInteractionRequirements; } + if(s=="IFCRELNESTS" ) { return IfcRelNests; } + if(s=="IFCRELOCCUPIESSPACES" ) { return IfcRelOccupiesSpaces; } + if(s=="IFCRELOVERRIDESPROPERTIES" ) { return IfcRelOverridesProperties; } + if(s=="IFCRELPROJECTSELEMENT" ) { return IfcRelProjectsElement; } + if(s=="IFCRELREFERENCEDINSPATIALSTRUCTURE" ) { return IfcRelReferencedInSpatialStructure; } + if(s=="IFCRELSCHEDULESCOSTITEMS" ) { return IfcRelSchedulesCostItems; } + if(s=="IFCRELSEQUENCE" ) { return IfcRelSequence; } + if(s=="IFCRELSERVICESBUILDINGS" ) { return IfcRelServicesBuildings; } + if(s=="IFCRELSPACEBOUNDARY" ) { return IfcRelSpaceBoundary; } + if(s=="IFCRELVOIDSELEMENT" ) { return IfcRelVoidsElement; } + if(s=="IFCRELATIONSHIP" ) { return IfcRelationship; } + if(s=="IFCRELAXATION" ) { return IfcRelaxation; } + if(s=="IFCREPRESENTATION" ) { return IfcRepresentation; } + if(s=="IFCREPRESENTATIONCONTEXT" ) { return IfcRepresentationContext; } + if(s=="IFCREPRESENTATIONITEM" ) { return IfcRepresentationItem; } + if(s=="IFCREPRESENTATIONMAP" ) { return IfcRepresentationMap; } + if(s=="IFCRESOURCE" ) { return IfcResource; } + if(s=="IFCREVOLVEDAREASOLID" ) { return IfcRevolvedAreaSolid; } + if(s=="IFCRIBPLATEPROFILEPROPERTIES" ) { return IfcRibPlateProfileProperties; } + if(s=="IFCRIGHTCIRCULARCONE" ) { return IfcRightCircularCone; } + if(s=="IFCRIGHTCIRCULARCYLINDER" ) { return IfcRightCircularCylinder; } + if(s=="IFCROOF" ) { return IfcRoof; } + if(s=="IFCROOT" ) { return IfcRoot; } + if(s=="IFCROUNDEDEDGEFEATURE" ) { return IfcRoundedEdgeFeature; } + if(s=="IFCROUNDEDRECTANGLEPROFILEDEF" ) { return IfcRoundedRectangleProfileDef; } + if(s=="IFCSIUNIT" ) { return IfcSIUnit; } + if(s=="IFCSANITARYTERMINALTYPE" ) { return IfcSanitaryTerminalType; } + if(s=="IFCSCHEDULETIMECONTROL" ) { return IfcScheduleTimeControl; } + if(s=="IFCSECTIONPROPERTIES" ) { return IfcSectionProperties; } + if(s=="IFCSECTIONREINFORCEMENTPROPERTIES" ) { return IfcSectionReinforcementProperties; } + if(s=="IFCSECTIONEDSPINE" ) { return IfcSectionedSpine; } + if(s=="IFCSENSORTYPE" ) { return IfcSensorType; } + if(s=="IFCSERVICELIFE" ) { return IfcServiceLife; } + if(s=="IFCSERVICELIFEFACTOR" ) { return IfcServiceLifeFactor; } + if(s=="IFCSHAPEASPECT" ) { return IfcShapeAspect; } + if(s=="IFCSHAPEMODEL" ) { return IfcShapeModel; } + if(s=="IFCSHAPEREPRESENTATION" ) { return IfcShapeRepresentation; } + if(s=="IFCSHELLBASEDSURFACEMODEL" ) { return IfcShellBasedSurfaceModel; } + if(s=="IFCSIMPLEPROPERTY" ) { return IfcSimpleProperty; } + if(s=="IFCSITE" ) { return IfcSite; } + if(s=="IFCSLAB" ) { return IfcSlab; } + if(s=="IFCSLABTYPE" ) { return IfcSlabType; } + if(s=="IFCSLIPPAGECONNECTIONCONDITION" ) { return IfcSlippageConnectionCondition; } + if(s=="IFCSOLIDMODEL" ) { return IfcSolidModel; } + if(s=="IFCSOUNDPROPERTIES" ) { return IfcSoundProperties; } + if(s=="IFCSOUNDVALUE" ) { return IfcSoundValue; } + if(s=="IFCSPACE" ) { return IfcSpace; } + if(s=="IFCSPACEHEATERTYPE" ) { return IfcSpaceHeaterType; } + if(s=="IFCSPACEPROGRAM" ) { return IfcSpaceProgram; } + if(s=="IFCSPACETHERMALLOADPROPERTIES" ) { return IfcSpaceThermalLoadProperties; } + if(s=="IFCSPACETYPE" ) { return IfcSpaceType; } + if(s=="IFCSPATIALSTRUCTUREELEMENT" ) { return IfcSpatialStructureElement; } + if(s=="IFCSPATIALSTRUCTUREELEMENTTYPE" ) { return IfcSpatialStructureElementType; } + if(s=="IFCSPHERE" ) { return IfcSphere; } + if(s=="IFCSTACKTERMINALTYPE" ) { return IfcStackTerminalType; } + if(s=="IFCSTAIR" ) { return IfcStair; } + if(s=="IFCSTAIRFLIGHT" ) { return IfcStairFlight; } + if(s=="IFCSTAIRFLIGHTTYPE" ) { return IfcStairFlightType; } + if(s=="IFCSTRUCTURALACTION" ) { return IfcStructuralAction; } + if(s=="IFCSTRUCTURALACTIVITY" ) { return IfcStructuralActivity; } + if(s=="IFCSTRUCTURALANALYSISMODEL" ) { return IfcStructuralAnalysisModel; } + if(s=="IFCSTRUCTURALCONNECTION" ) { return IfcStructuralConnection; } + if(s=="IFCSTRUCTURALCONNECTIONCONDITION" ) { return IfcStructuralConnectionCondition; } + if(s=="IFCSTRUCTURALCURVECONNECTION" ) { return IfcStructuralCurveConnection; } + if(s=="IFCSTRUCTURALCURVEMEMBER" ) { return IfcStructuralCurveMember; } + if(s=="IFCSTRUCTURALCURVEMEMBERVARYING" ) { return IfcStructuralCurveMemberVarying; } + if(s=="IFCSTRUCTURALITEM" ) { return IfcStructuralItem; } + if(s=="IFCSTRUCTURALLINEARACTION" ) { return IfcStructuralLinearAction; } + if(s=="IFCSTRUCTURALLINEARACTIONVARYING" ) { return IfcStructuralLinearActionVarying; } + if(s=="IFCSTRUCTURALLOAD" ) { return IfcStructuralLoad; } + if(s=="IFCSTRUCTURALLOADGROUP" ) { return IfcStructuralLoadGroup; } + if(s=="IFCSTRUCTURALLOADLINEARFORCE" ) { return IfcStructuralLoadLinearForce; } + if(s=="IFCSTRUCTURALLOADPLANARFORCE" ) { return IfcStructuralLoadPlanarForce; } + if(s=="IFCSTRUCTURALLOADSINGLEDISPLACEMENT" ) { return IfcStructuralLoadSingleDisplacement; } + if(s=="IFCSTRUCTURALLOADSINGLEDISPLACEMENTDISTORTION" ) { return IfcStructuralLoadSingleDisplacementDistortion; } + if(s=="IFCSTRUCTURALLOADSINGLEFORCE" ) { return IfcStructuralLoadSingleForce; } + if(s=="IFCSTRUCTURALLOADSINGLEFORCEWARPING" ) { return IfcStructuralLoadSingleForceWarping; } + if(s=="IFCSTRUCTURALLOADSTATIC" ) { return IfcStructuralLoadStatic; } + if(s=="IFCSTRUCTURALLOADTEMPERATURE" ) { return IfcStructuralLoadTemperature; } + if(s=="IFCSTRUCTURALMEMBER" ) { return IfcStructuralMember; } + if(s=="IFCSTRUCTURALPLANARACTION" ) { return IfcStructuralPlanarAction; } + if(s=="IFCSTRUCTURALPLANARACTIONVARYING" ) { return IfcStructuralPlanarActionVarying; } + if(s=="IFCSTRUCTURALPOINTACTION" ) { return IfcStructuralPointAction; } + if(s=="IFCSTRUCTURALPOINTCONNECTION" ) { return IfcStructuralPointConnection; } + if(s=="IFCSTRUCTURALPOINTREACTION" ) { return IfcStructuralPointReaction; } + if(s=="IFCSTRUCTURALPROFILEPROPERTIES" ) { return IfcStructuralProfileProperties; } + if(s=="IFCSTRUCTURALREACTION" ) { return IfcStructuralReaction; } + if(s=="IFCSTRUCTURALRESULTGROUP" ) { return IfcStructuralResultGroup; } + if(s=="IFCSTRUCTURALSTEELPROFILEPROPERTIES" ) { return IfcStructuralSteelProfileProperties; } + if(s=="IFCSTRUCTURALSURFACECONNECTION" ) { return IfcStructuralSurfaceConnection; } + if(s=="IFCSTRUCTURALSURFACEMEMBER" ) { return IfcStructuralSurfaceMember; } + if(s=="IFCSTRUCTURALSURFACEMEMBERVARYING" ) { return IfcStructuralSurfaceMemberVarying; } + if(s=="IFCSTRUCTUREDDIMENSIONCALLOUT" ) { return IfcStructuredDimensionCallout; } + if(s=="IFCSTYLEMODEL" ) { return IfcStyleModel; } + if(s=="IFCSTYLEDITEM" ) { return IfcStyledItem; } + if(s=="IFCSTYLEDREPRESENTATION" ) { return IfcStyledRepresentation; } + if(s=="IFCSUBCONTRACTRESOURCE" ) { return IfcSubContractResource; } + if(s=="IFCSUBEDGE" ) { return IfcSubedge; } + if(s=="IFCSURFACE" ) { return IfcSurface; } + if(s=="IFCSURFACECURVESWEPTAREASOLID" ) { return IfcSurfaceCurveSweptAreaSolid; } + if(s=="IFCSURFACEOFLINEAREXTRUSION" ) { return IfcSurfaceOfLinearExtrusion; } + if(s=="IFCSURFACEOFREVOLUTION" ) { return IfcSurfaceOfRevolution; } + if(s=="IFCSURFACESTYLE" ) { return IfcSurfaceStyle; } + if(s=="IFCSURFACESTYLELIGHTING" ) { return IfcSurfaceStyleLighting; } + if(s=="IFCSURFACESTYLEREFRACTION" ) { return IfcSurfaceStyleRefraction; } + if(s=="IFCSURFACESTYLERENDERING" ) { return IfcSurfaceStyleRendering; } + if(s=="IFCSURFACESTYLESHADING" ) { return IfcSurfaceStyleShading; } + if(s=="IFCSURFACESTYLEWITHTEXTURES" ) { return IfcSurfaceStyleWithTextures; } + if(s=="IFCSURFACETEXTURE" ) { return IfcSurfaceTexture; } + if(s=="IFCSWEPTAREASOLID" ) { return IfcSweptAreaSolid; } + if(s=="IFCSWEPTDISKSOLID" ) { return IfcSweptDiskSolid; } + if(s=="IFCSWEPTSURFACE" ) { return IfcSweptSurface; } + if(s=="IFCSWITCHINGDEVICETYPE" ) { return IfcSwitchingDeviceType; } + if(s=="IFCSYMBOLSTYLE" ) { return IfcSymbolStyle; } + if(s=="IFCSYSTEM" ) { return IfcSystem; } + if(s=="IFCSYSTEMFURNITUREELEMENTTYPE" ) { return IfcSystemFurnitureElementType; } + if(s=="IFCTSHAPEPROFILEDEF" ) { return IfcTShapeProfileDef; } + if(s=="IFCTABLE" ) { return IfcTable; } + if(s=="IFCTABLEROW" ) { return IfcTableRow; } + if(s=="IFCTANKTYPE" ) { return IfcTankType; } + if(s=="IFCTASK" ) { return IfcTask; } + if(s=="IFCTELECOMADDRESS" ) { return IfcTelecomAddress; } + if(s=="IFCTENDON" ) { return IfcTendon; } + if(s=="IFCTENDONANCHOR" ) { return IfcTendonAnchor; } + if(s=="IFCTERMINATORSYMBOL" ) { return IfcTerminatorSymbol; } + if(s=="IFCTEXTLITERAL" ) { return IfcTextLiteral; } + if(s=="IFCTEXTLITERALWITHEXTENT" ) { return IfcTextLiteralWithExtent; } + if(s=="IFCTEXTSTYLE" ) { return IfcTextStyle; } + if(s=="IFCTEXTSTYLEFONTMODEL" ) { return IfcTextStyleFontModel; } + if(s=="IFCTEXTSTYLEFORDEFINEDFONT" ) { return IfcTextStyleForDefinedFont; } + if(s=="IFCTEXTSTYLETEXTMODEL" ) { return IfcTextStyleTextModel; } + if(s=="IFCTEXTSTYLEWITHBOXCHARACTERISTICS" ) { return IfcTextStyleWithBoxCharacteristics; } + if(s=="IFCTEXTURECOORDINATE" ) { return IfcTextureCoordinate; } + if(s=="IFCTEXTURECOORDINATEGENERATOR" ) { return IfcTextureCoordinateGenerator; } + if(s=="IFCTEXTUREMAP" ) { return IfcTextureMap; } + if(s=="IFCTEXTUREVERTEX" ) { return IfcTextureVertex; } + if(s=="IFCTHERMALMATERIALPROPERTIES" ) { return IfcThermalMaterialProperties; } + if(s=="IFCTIMESERIES" ) { return IfcTimeSeries; } + if(s=="IFCTIMESERIESREFERENCERELATIONSHIP" ) { return IfcTimeSeriesReferenceRelationship; } + if(s=="IFCTIMESERIESSCHEDULE" ) { return IfcTimeSeriesSchedule; } + if(s=="IFCTIMESERIESVALUE" ) { return IfcTimeSeriesValue; } + if(s=="IFCTOPOLOGICALREPRESENTATIONITEM" ) { return IfcTopologicalRepresentationItem; } + if(s=="IFCTOPOLOGYREPRESENTATION" ) { return IfcTopologyRepresentation; } + if(s=="IFCTRANSFORMERTYPE" ) { return IfcTransformerType; } + if(s=="IFCTRANSPORTELEMENT" ) { return IfcTransportElement; } + if(s=="IFCTRANSPORTELEMENTTYPE" ) { return IfcTransportElementType; } + if(s=="IFCTRAPEZIUMPROFILEDEF" ) { return IfcTrapeziumProfileDef; } + if(s=="IFCTRIMMEDCURVE" ) { return IfcTrimmedCurve; } + if(s=="IFCTUBEBUNDLETYPE" ) { return IfcTubeBundleType; } + if(s=="IFCTWODIRECTIONREPEATFACTOR" ) { return IfcTwoDirectionRepeatFactor; } + if(s=="IFCTYPEOBJECT" ) { return IfcTypeObject; } + if(s=="IFCTYPEPRODUCT" ) { return IfcTypeProduct; } + if(s=="IFCUSHAPEPROFILEDEF" ) { return IfcUShapeProfileDef; } + if(s=="IFCUNITASSIGNMENT" ) { return IfcUnitAssignment; } + if(s=="IFCUNITARYEQUIPMENTTYPE" ) { return IfcUnitaryEquipmentType; } + if(s=="IFCVALVETYPE" ) { return IfcValveType; } + if(s=="IFCVECTOR" ) { return IfcVector; } + if(s=="IFCVERTEX" ) { return IfcVertex; } + if(s=="IFCVERTEXBASEDTEXTUREMAP" ) { return IfcVertexBasedTextureMap; } + if(s=="IFCVERTEXLOOP" ) { return IfcVertexLoop; } + if(s=="IFCVERTEXPOINT" ) { return IfcVertexPoint; } + if(s=="IFCVIBRATIONISOLATORTYPE" ) { return IfcVibrationIsolatorType; } + if(s=="IFCVIRTUALELEMENT" ) { return IfcVirtualElement; } + if(s=="IFCVIRTUALGRIDINTERSECTION" ) { return IfcVirtualGridIntersection; } + if(s=="IFCWALL" ) { return IfcWall; } + if(s=="IFCWALLSTANDARDCASE" ) { return IfcWallStandardCase; } + if(s=="IFCWALLTYPE" ) { return IfcWallType; } + if(s=="IFCWASTETERMINALTYPE" ) { return IfcWasteTerminalType; } + if(s=="IFCWATERPROPERTIES" ) { return IfcWaterProperties; } + if(s=="IFCWINDOW" ) { return IfcWindow; } + if(s=="IFCWINDOWLININGPROPERTIES" ) { return IfcWindowLiningProperties; } + if(s=="IFCWINDOWPANELPROPERTIES" ) { return IfcWindowPanelProperties; } + if(s=="IFCWINDOWSTYLE" ) { return IfcWindowStyle; } + if(s=="IFCWORKCONTROL" ) { return IfcWorkControl; } + if(s=="IFCWORKPLAN" ) { return IfcWorkPlan; } + if(s=="IFCWORKSCHEDULE" ) { return IfcWorkSchedule; } + if(s=="IFCZSHAPEPROFILEDEF" ) { return IfcZShapeProfileDef; } + if(s=="IFCZONE" ) { return IfcZone; } + throw; +} +std::string IfcActionSourceTypeEnum::ToString(IfcActionSourceTypeEnum v) { + if (v < 0 || v >= 27) throw; + const char* names[] = { "DEAD_LOAD_G","COMPLETION_G1","LIVE_LOAD_Q","SNOW_S","WIND_W","PRESTRESSING_P","SETTLEMENT_U","TEMPERATURE_T","EARTHQUAKE_E","FIRE","IMPULSE","IMPACT","TRANSPORT","ERECTION","PROPPING","SYSTEM_IMPERFECTION","SHRINKAGE","CREEP","LACK_OF_FIT","BUOYANCY","ICE","CURRENT","WAVE","RAIN","BRAKES","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcActionTypeEnum::ToString(IfcActionTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "PERMANENT_G","VARIABLE_Q","EXTRAORDINARY_A","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcActuatorTypeEnum::ToString(IfcActuatorTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "ELECTRICACTUATOR","HANDOPERATEDACTUATOR","HYDRAULICACTUATOR","PNEUMATICACTUATOR","THERMOSTATICACTUATOR","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcAddressTypeEnum::ToString(IfcAddressTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "OFFICE","SITE","HOME","DISTRIBUTIONPOINT","USERDEFINED" }; + return names[v]; +} +std::string IfcAheadOrBehind::ToString(IfcAheadOrBehind v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "AHEAD","BEHIND" }; + return names[v]; +} +std::string IfcAirTerminalBoxTypeEnum::ToString(IfcAirTerminalBoxTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "CONSTANTFLOW","VARIABLEFLOWPRESSUREDEPENDANT","VARIABLEFLOWPRESSUREINDEPENDANT","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcAirTerminalTypeEnum::ToString(IfcAirTerminalTypeEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "GRILLE","REGISTER","DIFFUSER","EYEBALL","IRIS","LINEARGRILLE","LINEARDIFFUSER","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcAirToAirHeatRecoveryTypeEnum::ToString(IfcAirToAirHeatRecoveryTypeEnum v) { + if (v < 0 || v >= 11) throw; + const char* names[] = { "FIXEDPLATECOUNTERFLOWEXCHANGER","FIXEDPLATECROSSFLOWEXCHANGER","FIXEDPLATEPARALLELFLOWEXCHANGER","ROTARYWHEEL","RUNAROUNDCOILLOOP","HEATPIPE","TWINTOWERENTHALPYRECOVERYLOOPS","THERMOSIPHONSEALEDTUBEHEATEXCHANGERS","THERMOSIPHONCOILTYPEHEATEXCHANGERS","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcAlarmTypeEnum::ToString(IfcAlarmTypeEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "BELL","BREAKGLASSBUTTON","LIGHT","MANUALPULLBOX","SIREN","WHISTLE","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcAnalysisModelTypeEnum::ToString(IfcAnalysisModelTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "IN_PLANE_LOADING_2D","OUT_PLANE_LOADING_2D","LOADING_3D","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcAnalysisTheoryTypeEnum::ToString(IfcAnalysisTheoryTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "FIRST_ORDER_THEORY","SECOND_ORDER_THEORY","THIRD_ORDER_THEORY","FULL_NONLINEAR_THEORY","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcArithmeticOperatorEnum::ToString(IfcArithmeticOperatorEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "ADD","DIVIDE","MULTIPLY","SUBTRACT" }; + return names[v]; +} +std::string IfcAssemblyPlaceEnum::ToString(IfcAssemblyPlaceEnum v) { + if (v < 0 || v >= 3) throw; + const char* names[] = { "SITE","FACTORY","NOTDEFINED" }; + return names[v]; +} +std::string IfcBSplineCurveForm::ToString(IfcBSplineCurveForm v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "POLYLINE_FORM","CIRCULAR_ARC","ELLIPTIC_ARC","PARABOLIC_ARC","HYPERBOLIC_ARC","UNSPECIFIED" }; + return names[v]; +} +std::string IfcBeamTypeEnum::ToString(IfcBeamTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "BEAM","JOIST","LINTEL","T_BEAM","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcBenchmarkEnum::ToString(IfcBenchmarkEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "GREATERTHAN","GREATERTHANOREQUALTO","LESSTHAN","LESSTHANOREQUALTO","EQUALTO","NOTEQUALTO" }; + return names[v]; +} +std::string IfcBoilerTypeEnum::ToString(IfcBoilerTypeEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "WATER","STEAM","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcBooleanOperator::ToString(IfcBooleanOperator v) { + if (v < 0 || v >= 3) throw; + const char* names[] = { "UNION","INTERSECTION","DIFFERENCE" }; + return names[v]; +} +std::string IfcBuildingElementProxyTypeEnum::ToString(IfcBuildingElementProxyTypeEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcCableCarrierFittingTypeEnum::ToString(IfcCableCarrierFittingTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "BEND","CROSS","REDUCER","TEE","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcCableCarrierSegmentTypeEnum::ToString(IfcCableCarrierSegmentTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "CABLELADDERSEGMENT","CABLETRAYSEGMENT","CABLETRUNKINGSEGMENT","CONDUITSEGMENT","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcCableSegmentTypeEnum::ToString(IfcCableSegmentTypeEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "CABLESEGMENT","CONDUCTORSEGMENT","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcChangeActionEnum::ToString(IfcChangeActionEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "NOCHANGE","MODIFIED","ADDED","DELETED","MODIFIEDADDED","MODIFIEDDELETED" }; + return names[v]; +} +std::string IfcChillerTypeEnum::ToString(IfcChillerTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "AIRCOOLED","WATERCOOLED","HEATRECOVERY","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcCoilTypeEnum::ToString(IfcCoilTypeEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "DXCOOLINGCOIL","WATERCOOLINGCOIL","STEAMHEATINGCOIL","WATERHEATINGCOIL","ELECTRICHEATINGCOIL","GASHEATINGCOIL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcColumnTypeEnum::ToString(IfcColumnTypeEnum v) { + if (v < 0 || v >= 3) throw; + const char* names[] = { "COLUMN","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcCompressorTypeEnum::ToString(IfcCompressorTypeEnum v) { + if (v < 0 || v >= 17) throw; + const char* names[] = { "DYNAMIC","RECIPROCATING","ROTARY","SCROLL","TROCHOIDAL","SINGLESTAGE","BOOSTER","OPENTYPE","HERMETIC","SEMIHERMETIC","WELDEDSHELLHERMETIC","ROLLINGPISTON","ROTARYVANE","SINGLESCREW","TWINSCREW","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcCondenserTypeEnum::ToString(IfcCondenserTypeEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "WATERCOOLEDSHELLTUBE","WATERCOOLEDSHELLCOIL","WATERCOOLEDTUBEINTUBE","WATERCOOLEDBRAZEDPLATE","AIRCOOLED","EVAPORATIVECOOLED","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcConnectionTypeEnum::ToString(IfcConnectionTypeEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "ATPATH","ATSTART","ATEND","NOTDEFINED" }; + return names[v]; +} +std::string IfcConstraintEnum::ToString(IfcConstraintEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "HARD","SOFT","ADVISORY","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcControllerTypeEnum::ToString(IfcControllerTypeEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "FLOATING","PROPORTIONAL","PROPORTIONALINTEGRAL","PROPORTIONALINTEGRALDERIVATIVE","TIMEDTWOPOSITION","TWOPOSITION","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcCooledBeamTypeEnum::ToString(IfcCooledBeamTypeEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "ACTIVE","PASSIVE","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcCoolingTowerTypeEnum::ToString(IfcCoolingTowerTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "NATURALDRAFT","MECHANICALINDUCEDDRAFT","MECHANICALFORCEDDRAFT","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcCostScheduleTypeEnum::ToString(IfcCostScheduleTypeEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "BUDGET","COSTPLAN","ESTIMATE","TENDER","PRICEDBILLOFQUANTITIES","UNPRICEDBILLOFQUANTITIES","SCHEDULEOFRATES","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcCoveringTypeEnum::ToString(IfcCoveringTypeEnum v) { + if (v < 0 || v >= 10) throw; + const char* names[] = { "CEILING","FLOORING","CLADDING","ROOFING","INSULATION","MEMBRANE","SLEEVING","WRAPPING","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcCurrencyEnum::ToString(IfcCurrencyEnum v) { + if (v < 0 || v >= 83) throw; + const char* names[] = { "AED","AES","ATS","AUD","BBD","BEG","BGL","BHD","BMD","BND","BRL","BSD","BWP","BZD","CAD","CBD","CHF","CLP","CNY","CYS","CZK","DDP","DEM","DKK","EGL","EST","EUR","FAK","FIM","FJD","FKP","FRF","GBP","GIP","GMD","GRX","HKD","HUF","ICK","IDR","ILS","INR","IRP","ITL","JMD","JOD","JPY","KES","KRW","KWD","KYD","LKR","LUF","MTL","MUR","MXN","MYR","NLG","NZD","OMR","PGK","PHP","PKR","PLN","PTN","QAR","RUR","SAR","SCR","SEK","SGD","SKP","THB","TRL","TTD","TWD","USD","VEB","VND","XEU","ZAR","ZWD","NOK" }; + return names[v]; +} +std::string IfcCurtainWallTypeEnum::ToString(IfcCurtainWallTypeEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcDamperTypeEnum::ToString(IfcDamperTypeEnum v) { + if (v < 0 || v >= 13) throw; + const char* names[] = { "CONTROLDAMPER","FIREDAMPER","SMOKEDAMPER","FIRESMOKEDAMPER","BACKDRAFTDAMPER","RELIEFDAMPER","BLASTDAMPER","GRAVITYDAMPER","GRAVITYRELIEFDAMPER","BALANCINGDAMPER","FUMEHOODEXHAUST","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcDataOriginEnum::ToString(IfcDataOriginEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "MEASURED","PREDICTED","SIMULATED","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcDerivedUnitEnum::ToString(IfcDerivedUnitEnum v) { + if (v < 0 || v >= 49) throw; + const char* names[] = { "ANGULARVELOCITYUNIT","COMPOUNDPLANEANGLEUNIT","DYNAMICVISCOSITYUNIT","HEATFLUXDENSITYUNIT","INTEGERCOUNTRATEUNIT","ISOTHERMALMOISTURECAPACITYUNIT","KINEMATICVISCOSITYUNIT","LINEARVELOCITYUNIT","MASSDENSITYUNIT","MASSFLOWRATEUNIT","MOISTUREDIFFUSIVITYUNIT","MOLECULARWEIGHTUNIT","SPECIFICHEATCAPACITYUNIT","THERMALADMITTANCEUNIT","THERMALCONDUCTANCEUNIT","THERMALRESISTANCEUNIT","THERMALTRANSMITTANCEUNIT","VAPORPERMEABILITYUNIT","VOLUMETRICFLOWRATEUNIT","ROTATIONALFREQUENCYUNIT","TORQUEUNIT","MOMENTOFINERTIAUNIT","LINEARMOMENTUNIT","LINEARFORCEUNIT","PLANARFORCEUNIT","MODULUSOFELASTICITYUNIT","SHEARMODULUSUNIT","LINEARSTIFFNESSUNIT","ROTATIONALSTIFFNESSUNIT","MODULUSOFSUBGRADEREACTIONUNIT","ACCELERATIONUNIT","CURVATUREUNIT","HEATINGVALUEUNIT","IONCONCENTRATIONUNIT","LUMINOUSINTENSITYDISTRIBUTIONUNIT","MASSPERLENGTHUNIT","MODULUSOFLINEARSUBGRADEREACTIONUNIT","MODULUSOFROTATIONALSUBGRADEREACTIONUNIT","PHUNIT","ROTATIONALMASSUNIT","SECTIONAREAINTEGRALUNIT","SECTIONMODULUSUNIT","SOUNDPOWERUNIT","SOUNDPRESSUREUNIT","TEMPERATUREGRADIENTUNIT","THERMALEXPANSIONCOEFFICIENTUNIT","WARPINGCONSTANTUNIT","WARPINGMOMENTUNIT","USERDEFINED" }; + return names[v]; +} +std::string IfcDimensionExtentUsage::ToString(IfcDimensionExtentUsage v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "ORIGIN","TARGET" }; + return names[v]; +} +std::string IfcDirectionSenseEnum::ToString(IfcDirectionSenseEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "POSITIVE","NEGATIVE" }; + return names[v]; +} +std::string IfcDistributionChamberElementTypeEnum::ToString(IfcDistributionChamberElementTypeEnum v) { + if (v < 0 || v >= 10) throw; + const char* names[] = { "FORMEDDUCT","INSPECTIONCHAMBER","INSPECTIONPIT","MANHOLE","METERCHAMBER","SUMP","TRENCH","VALVECHAMBER","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcDocumentConfidentialityEnum::ToString(IfcDocumentConfidentialityEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "PUBLIC","RESTRICTED","CONFIDENTIAL","PERSONAL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcDocumentStatusEnum::ToString(IfcDocumentStatusEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "DRAFT","FINALDRAFT","FINAL","REVISION","NOTDEFINED" }; + return names[v]; +} +std::string IfcDoorPanelOperationEnum::ToString(IfcDoorPanelOperationEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "SWINGING","DOUBLE_ACTING","SLIDING","FOLDING","REVOLVING","ROLLINGUP","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcDoorPanelPositionEnum::ToString(IfcDoorPanelPositionEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "LEFT","MIDDLE","RIGHT","NOTDEFINED" }; + return names[v]; +} +std::string IfcDoorStyleConstructionEnum::ToString(IfcDoorStyleConstructionEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "ALUMINIUM","HIGH_GRADE_STEEL","STEEL","WOOD","ALUMINIUM_WOOD","ALUMINIUM_PLASTIC","PLASTIC","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcDoorStyleOperationEnum::ToString(IfcDoorStyleOperationEnum v) { + if (v < 0 || v >= 18) throw; + const char* names[] = { "SINGLE_SWING_LEFT","SINGLE_SWING_RIGHT","DOUBLE_DOOR_SINGLE_SWING","DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT","DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT","DOUBLE_SWING_LEFT","DOUBLE_SWING_RIGHT","DOUBLE_DOOR_DOUBLE_SWING","SLIDING_TO_LEFT","SLIDING_TO_RIGHT","DOUBLE_DOOR_SLIDING","FOLDING_TO_LEFT","FOLDING_TO_RIGHT","DOUBLE_DOOR_FOLDING","REVOLVING","ROLLINGUP","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcDuctFittingTypeEnum::ToString(IfcDuctFittingTypeEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "BEND","CONNECTOR","ENTRY","EXIT","JUNCTION","OBSTRUCTION","TRANSITION","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcDuctSegmentTypeEnum::ToString(IfcDuctSegmentTypeEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "RIGIDSEGMENT","FLEXIBLESEGMENT","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcDuctSilencerTypeEnum::ToString(IfcDuctSilencerTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "FLATOVAL","RECTANGULAR","ROUND","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcElectricApplianceTypeEnum::ToString(IfcElectricApplianceTypeEnum v) { + if (v < 0 || v >= 26) throw; + const char* names[] = { "COMPUTER","DIRECTWATERHEATER","DISHWASHER","ELECTRICCOOKER","ELECTRICHEATER","FACSIMILE","FREESTANDINGFAN","FREEZER","FRIDGE_FREEZER","HANDDRYER","INDIRECTWATERHEATER","MICROWAVE","PHOTOCOPIER","PRINTER","REFRIGERATOR","RADIANTHEATER","SCANNER","TELEPHONE","TUMBLEDRYER","TV","VENDINGMACHINE","WASHINGMACHINE","WATERHEATER","WATERCOOLER","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcElectricCurrentEnum::ToString(IfcElectricCurrentEnum v) { + if (v < 0 || v >= 3) throw; + const char* names[] = { "ALTERNATING","DIRECT","NOTDEFINED" }; + return names[v]; +} +std::string IfcElectricDistributionPointFunctionEnum::ToString(IfcElectricDistributionPointFunctionEnum v) { + if (v < 0 || v >= 11) throw; + const char* names[] = { "ALARMPANEL","CONSUMERUNIT","CONTROLPANEL","DISTRIBUTIONBOARD","GASDETECTORPANEL","INDICATORPANEL","MIMICPANEL","MOTORCONTROLCENTRE","SWITCHBOARD","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcElectricFlowStorageDeviceTypeEnum::ToString(IfcElectricFlowStorageDeviceTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "BATTERY","CAPACITORBANK","HARMONICFILTER","INDUCTORBANK","UPS","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcElectricGeneratorTypeEnum::ToString(IfcElectricGeneratorTypeEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcElectricHeaterTypeEnum::ToString(IfcElectricHeaterTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "ELECTRICPOINTHEATER","ELECTRICCABLEHEATER","ELECTRICMATHEATER","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcElectricMotorTypeEnum::ToString(IfcElectricMotorTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "DC","INDUCTION","POLYPHASE","RELUCTANCESYNCHRONOUS","SYNCHRONOUS","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcElectricTimeControlTypeEnum::ToString(IfcElectricTimeControlTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "TIMECLOCK","TIMEDELAY","RELAY","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcElementAssemblyTypeEnum::ToString(IfcElementAssemblyTypeEnum v) { + if (v < 0 || v >= 11) throw; + const char* names[] = { "ACCESSORY_ASSEMBLY","ARCH","BEAM_GRID","BRACED_FRAME","GIRDER","REINFORCEMENT_UNIT","RIGID_FRAME","SLAB_FIELD","TRUSS","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcElementCompositionEnum::ToString(IfcElementCompositionEnum v) { + if (v < 0 || v >= 3) throw; + const char* names[] = { "COMPLEX","ELEMENT","PARTIAL" }; + return names[v]; +} +std::string IfcEnergySequenceEnum::ToString(IfcEnergySequenceEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "PRIMARY","SECONDARY","TERTIARY","AUXILIARY","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcEnvironmentalImpactCategoryEnum::ToString(IfcEnvironmentalImpactCategoryEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "COMBINEDVALUE","DISPOSAL","EXTRACTION","INSTALLATION","MANUFACTURE","TRANSPORTATION","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcEvaporativeCoolerTypeEnum::ToString(IfcEvaporativeCoolerTypeEnum v) { + if (v < 0 || v >= 11) throw; + const char* names[] = { "DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER","DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER","DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER","DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER","DIRECTEVAPORATIVEAIRWASHER","INDIRECTEVAPORATIVEPACKAGEAIRCOOLER","INDIRECTEVAPORATIVEWETCOIL","INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER","INDIRECTDIRECTCOMBINATION","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcEvaporatorTypeEnum::ToString(IfcEvaporatorTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "DIRECTEXPANSIONSHELLANDTUBE","DIRECTEXPANSIONTUBEINTUBE","DIRECTEXPANSIONBRAZEDPLATE","FLOODEDSHELLANDTUBE","SHELLANDCOIL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcFanTypeEnum::ToString(IfcFanTypeEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "CENTRIFUGALFORWARDCURVED","CENTRIFUGALRADIAL","CENTRIFUGALBACKWARDINCLINEDCURVED","CENTRIFUGALAIRFOIL","TUBEAXIAL","VANEAXIAL","PROPELLORAXIAL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcFilterTypeEnum::ToString(IfcFilterTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "AIRPARTICLEFILTER","ODORFILTER","OILFILTER","STRAINER","WATERFILTER","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcFireSuppressionTerminalTypeEnum::ToString(IfcFireSuppressionTerminalTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "BREECHINGINLET","FIREHYDRANT","HOSEREEL","SPRINKLER","SPRINKLERDEFLECTOR","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcFlowDirectionEnum::ToString(IfcFlowDirectionEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "SOURCE","SINK","SOURCEANDSINK","NOTDEFINED" }; + return names[v]; +} +std::string IfcFlowInstrumentTypeEnum::ToString(IfcFlowInstrumentTypeEnum v) { + if (v < 0 || v >= 10) throw; + const char* names[] = { "PRESSUREGAUGE","THERMOMETER","AMMETER","FREQUENCYMETER","POWERFACTORMETER","PHASEANGLEMETER","VOLTMETER_PEAK","VOLTMETER_RMS","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcFlowMeterTypeEnum::ToString(IfcFlowMeterTypeEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "ELECTRICMETER","ENERGYMETER","FLOWMETER","GASMETER","OILMETER","WATERMETER","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcFootingTypeEnum::ToString(IfcFootingTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "FOOTING_BEAM","PAD_FOOTING","PILE_CAP","STRIP_FOOTING","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcGasTerminalTypeEnum::ToString(IfcGasTerminalTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "GASAPPLIANCE","GASBOOSTER","GASBURNER","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcGeometricProjectionEnum::ToString(IfcGeometricProjectionEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "GRAPH_VIEW","SKETCH_VIEW","MODEL_VIEW","PLAN_VIEW","REFLECTED_PLAN_VIEW","SECTION_VIEW","ELEVATION_VIEW","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcGlobalOrLocalEnum::ToString(IfcGlobalOrLocalEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "GLOBAL_COORDS","LOCAL_COORDS" }; + return names[v]; +} +std::string IfcHeatExchangerTypeEnum::ToString(IfcHeatExchangerTypeEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "PLATE","SHELLANDTUBE","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcHumidifierTypeEnum::ToString(IfcHumidifierTypeEnum v) { + if (v < 0 || v >= 15) throw; + const char* names[] = { "STEAMINJECTION","ADIABATICAIRWASHER","ADIABATICPAN","ADIABATICWETTEDELEMENT","ADIABATICATOMIZING","ADIABATICULTRASONIC","ADIABATICRIGIDMEDIA","ADIABATICCOMPRESSEDAIRNOZZLE","ASSISTEDELECTRIC","ASSISTEDNATURALGAS","ASSISTEDPROPANE","ASSISTEDBUTANE","ASSISTEDSTEAM","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcInternalOrExternalEnum::ToString(IfcInternalOrExternalEnum v) { + if (v < 0 || v >= 3) throw; + const char* names[] = { "INTERNAL","EXTERNAL","NOTDEFINED" }; + return names[v]; +} +std::string IfcInventoryTypeEnum::ToString(IfcInventoryTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "ASSETINVENTORY","SPACEINVENTORY","FURNITUREINVENTORY","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcJunctionBoxTypeEnum::ToString(IfcJunctionBoxTypeEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcLampTypeEnum::ToString(IfcLampTypeEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "COMPACTFLUORESCENT","FLUORESCENT","HIGHPRESSUREMERCURY","HIGHPRESSURESODIUM","METALHALIDE","TUNGSTENFILAMENT","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcLayerSetDirectionEnum::ToString(IfcLayerSetDirectionEnum v) { + if (v < 0 || v >= 3) throw; + const char* names[] = { "AXIS1","AXIS2","AXIS3" }; + return names[v]; +} +std::string IfcLightDistributionCurveEnum::ToString(IfcLightDistributionCurveEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "TYPE_A","TYPE_B","TYPE_C","NOTDEFINED" }; + return names[v]; +} +std::string IfcLightEmissionSourceEnum::ToString(IfcLightEmissionSourceEnum v) { + if (v < 0 || v >= 11) throw; + const char* names[] = { "COMPACTFLUORESCENT","FLUORESCENT","HIGHPRESSUREMERCURY","HIGHPRESSURESODIUM","LIGHTEMITTINGDIODE","LOWPRESSURESODIUM","LOWVOLTAGEHALOGEN","MAINVOLTAGEHALOGEN","METALHALIDE","TUNGSTENFILAMENT","NOTDEFINED" }; + return names[v]; +} +std::string IfcLightFixtureTypeEnum::ToString(IfcLightFixtureTypeEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "POINTSOURCE","DIRECTIONSOURCE","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcLoadGroupTypeEnum::ToString(IfcLoadGroupTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "LOAD_GROUP","LOAD_CASE","LOAD_COMBINATION_GROUP","LOAD_COMBINATION","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcLogicalOperatorEnum::ToString(IfcLogicalOperatorEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "LOGICALAND","LOGICALOR" }; + return names[v]; +} +std::string IfcMemberTypeEnum::ToString(IfcMemberTypeEnum v) { + if (v < 0 || v >= 14) throw; + const char* names[] = { "BRACE","CHORD","COLLAR","MEMBER","MULLION","PLATE","POST","PURLIN","RAFTER","STRINGER","STRUT","STUD","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcMotorConnectionTypeEnum::ToString(IfcMotorConnectionTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "BELTDRIVE","COUPLING","DIRECTDRIVE","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcNullStyle::ToString(IfcNullStyle v) { + if (v < 0 || v >= 1) throw; + const char* names[] = { "IFC_NULL" }; + return names[v]; +} +std::string IfcObjectTypeEnum::ToString(IfcObjectTypeEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "PRODUCT","PROCESS","CONTROL","RESOURCE","ACTOR","GROUP","PROJECT","NOTDEFINED" }; + return names[v]; +} +std::string IfcObjectiveEnum::ToString(IfcObjectiveEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "CODECOMPLIANCE","DESIGNINTENT","HEALTHANDSAFETY","REQUIREMENT","SPECIFICATION","TRIGGERCONDITION","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcOccupantTypeEnum::ToString(IfcOccupantTypeEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "ASSIGNEE","ASSIGNOR","LESSEE","LESSOR","LETTINGAGENT","OWNER","TENANT","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcOutletTypeEnum::ToString(IfcOutletTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "AUDIOVISUALOUTLET","COMMUNICATIONSOUTLET","POWEROUTLET","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcPermeableCoveringOperationEnum::ToString(IfcPermeableCoveringOperationEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "GRILL","LOUVER","SCREEN","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcPhysicalOrVirtualEnum::ToString(IfcPhysicalOrVirtualEnum v) { + if (v < 0 || v >= 3) throw; + const char* names[] = { "PHYSICAL","VIRTUAL","NOTDEFINED" }; + return names[v]; +} +std::string IfcPileConstructionEnum::ToString(IfcPileConstructionEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "CAST_IN_PLACE","COMPOSITE","PRECAST_CONCRETE","PREFAB_STEEL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcPileTypeEnum::ToString(IfcPileTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "COHESION","FRICTION","SUPPORT","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcPipeFittingTypeEnum::ToString(IfcPipeFittingTypeEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "BEND","CONNECTOR","ENTRY","EXIT","JUNCTION","OBSTRUCTION","TRANSITION","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcPipeSegmentTypeEnum::ToString(IfcPipeSegmentTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "FLEXIBLESEGMENT","RIGIDSEGMENT","GUTTER","SPOOL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcPlateTypeEnum::ToString(IfcPlateTypeEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "CURTAIN_PANEL","SHEET","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcProcedureTypeEnum::ToString(IfcProcedureTypeEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "ADVICE_CAUTION","ADVICE_NOTE","ADVICE_WARNING","CALIBRATION","DIAGNOSTIC","SHUTDOWN","STARTUP","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcProfileTypeEnum::ToString(IfcProfileTypeEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "CURVE","AREA" }; + return names[v]; +} +std::string IfcProjectOrderRecordTypeEnum::ToString(IfcProjectOrderRecordTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "CHANGE","MAINTENANCE","MOVE","PURCHASE","WORK","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcProjectOrderTypeEnum::ToString(IfcProjectOrderTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "CHANGEORDER","MAINTENANCEWORKORDER","MOVEORDER","PURCHASEORDER","WORKORDER","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcProjectedOrTrueLengthEnum::ToString(IfcProjectedOrTrueLengthEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "PROJECTED_LENGTH","TRUE_LENGTH" }; + return names[v]; +} +std::string IfcPropertySourceEnum::ToString(IfcPropertySourceEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "DESIGN","DESIGNMAXIMUM","DESIGNMINIMUM","SIMULATED","ASBUILT","COMMISSIONING","MEASURED","USERDEFINED","NOTKNOWN" }; + return names[v]; +} +std::string IfcProtectiveDeviceTypeEnum::ToString(IfcProtectiveDeviceTypeEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "FUSEDISCONNECTOR","CIRCUITBREAKER","EARTHFAILUREDEVICE","RESIDUALCURRENTCIRCUITBREAKER","RESIDUALCURRENTSWITCH","VARISTOR","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcPumpTypeEnum::ToString(IfcPumpTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "CIRCULATOR","ENDSUCTION","SPLITCASE","VERTICALINLINE","VERTICALTURBINE","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcRailingTypeEnum::ToString(IfcRailingTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "HANDRAIL","GUARDRAIL","BALUSTRADE","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcRampFlightTypeEnum::ToString(IfcRampFlightTypeEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "STRAIGHT","SPIRAL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcRampTypeEnum::ToString(IfcRampTypeEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "STRAIGHT_RUN_RAMP","TWO_STRAIGHT_RUN_RAMP","QUARTER_TURN_RAMP","TWO_QUARTER_TURN_RAMP","HALF_TURN_RAMP","SPIRAL_RAMP","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcReflectanceMethodEnum::ToString(IfcReflectanceMethodEnum v) { + if (v < 0 || v >= 10) throw; + const char* names[] = { "BLINN","FLAT","GLASS","MATT","METAL","MIRROR","PHONG","PLASTIC","STRAUSS","NOTDEFINED" }; + return names[v]; +} +std::string IfcReinforcingBarRoleEnum::ToString(IfcReinforcingBarRoleEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "MAIN","SHEAR","LIGATURE","STUD","PUNCHING","EDGE","RING","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcReinforcingBarSurfaceEnum::ToString(IfcReinforcingBarSurfaceEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "PLAIN","TEXTURED" }; + return names[v]; +} +std::string IfcResourceConsumptionEnum::ToString(IfcResourceConsumptionEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "CONSUMED","PARTIALLYCONSUMED","NOTCONSUMED","OCCUPIED","PARTIALLYOCCUPIED","NOTOCCUPIED","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcRibPlateDirectionEnum::ToString(IfcRibPlateDirectionEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "DIRECTION_X","DIRECTION_Y" }; + return names[v]; +} +std::string IfcRoleEnum::ToString(IfcRoleEnum v) { + if (v < 0 || v >= 23) throw; + const char* names[] = { "SUPPLIER","MANUFACTURER","CONTRACTOR","SUBCONTRACTOR","ARCHITECT","STRUCTURALENGINEER","COSTENGINEER","CLIENT","BUILDINGOWNER","BUILDINGOPERATOR","MECHANICALENGINEER","ELECTRICALENGINEER","PROJECTMANAGER","FACILITIESMANAGER","CIVILENGINEER","COMISSIONINGENGINEER","ENGINEER","OWNER","CONSULTANT","CONSTRUCTIONMANAGER","FIELDCONSTRUCTIONMANAGER","RESELLER","USERDEFINED" }; + return names[v]; +} +std::string IfcRoofTypeEnum::ToString(IfcRoofTypeEnum v) { + if (v < 0 || v >= 14) throw; + const char* names[] = { "FLAT_ROOF","SHED_ROOF","GABLE_ROOF","HIP_ROOF","HIPPED_GABLE_ROOF","GAMBREL_ROOF","MANSARD_ROOF","BARREL_ROOF","RAINBOW_ROOF","BUTTERFLY_ROOF","PAVILION_ROOF","DOME_ROOF","FREEFORM","NOTDEFINED" }; + return names[v]; +} +std::string IfcSIPrefix::ToString(IfcSIPrefix v) { + if (v < 0 || v >= 16) throw; + const char* names[] = { "EXA","PETA","TERA","GIGA","MEGA","KILO","HECTO","DECA","DECI","CENTI","MILLI","MICRO","NANO","PICO","FEMTO","ATTO" }; + return names[v]; +} +std::string IfcSIUnitName::ToString(IfcSIUnitName v) { + if (v < 0 || v >= 30) throw; + const char* names[] = { "AMPERE","BECQUEREL","CANDELA","COULOMB","CUBIC_METRE","DEGREE_CELSIUS","FARAD","GRAM","GRAY","HENRY","HERTZ","JOULE","KELVIN","LUMEN","LUX","METRE","MOLE","NEWTON","OHM","PASCAL","RADIAN","SECOND","SIEMENS","SIEVERT","SQUARE_METRE","STERADIAN","TESLA","VOLT","WATT","WEBER" }; + return names[v]; +} +std::string IfcSanitaryTerminalTypeEnum::ToString(IfcSanitaryTerminalTypeEnum v) { + if (v < 0 || v >= 12) throw; + const char* names[] = { "BATH","BIDET","CISTERN","SHOWER","SINK","SANITARYFOUNTAIN","TOILETPAN","URINAL","WASHHANDBASIN","WCSEAT","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcSectionTypeEnum::ToString(IfcSectionTypeEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "UNIFORM","TAPERED" }; + return names[v]; +} +std::string IfcSensorTypeEnum::ToString(IfcSensorTypeEnum v) { + if (v < 0 || v >= 15) throw; + const char* names[] = { "CO2SENSOR","FIRESENSOR","FLOWSENSOR","GASSENSOR","HEATSENSOR","HUMIDITYSENSOR","LIGHTSENSOR","MOISTURESENSOR","MOVEMENTSENSOR","PRESSURESENSOR","SMOKESENSOR","SOUNDSENSOR","TEMPERATURESENSOR","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcSequenceEnum::ToString(IfcSequenceEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "START_START","START_FINISH","FINISH_START","FINISH_FINISH","NOTDEFINED" }; + return names[v]; +} +std::string IfcServiceLifeFactorTypeEnum::ToString(IfcServiceLifeFactorTypeEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "A_QUALITYOFCOMPONENTS","B_DESIGNLEVEL","C_WORKEXECUTIONLEVEL","D_INDOORENVIRONMENT","E_OUTDOORENVIRONMENT","F_INUSECONDITIONS","G_MAINTENANCELEVEL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcServiceLifeTypeEnum::ToString(IfcServiceLifeTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "ACTUALSERVICELIFE","EXPECTEDSERVICELIFE","OPTIMISTICREFERENCESERVICELIFE","PESSIMISTICREFERENCESERVICELIFE","REFERENCESERVICELIFE" }; + return names[v]; +} +std::string IfcSlabTypeEnum::ToString(IfcSlabTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "FLOOR","ROOF","LANDING","BASESLAB","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcSoundScaleEnum::ToString(IfcSoundScaleEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "DBA","DBB","DBC","NC","NR","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcSpaceHeaterTypeEnum::ToString(IfcSpaceHeaterTypeEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "SECTIONALRADIATOR","PANELRADIATOR","TUBULARRADIATOR","CONVECTOR","BASEBOARDHEATER","FINNEDTUBEUNIT","UNITHEATER","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcSpaceTypeEnum::ToString(IfcSpaceTypeEnum v) { + if (v < 0 || v >= 2) throw; + const char* names[] = { "USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcStackTerminalTypeEnum::ToString(IfcStackTerminalTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "BIRDCAGE","COWL","RAINWATERHOPPER","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcStairFlightTypeEnum::ToString(IfcStairFlightTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "STRAIGHT","WINDER","SPIRAL","CURVED","FREEFORM","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcStairTypeEnum::ToString(IfcStairTypeEnum v) { + if (v < 0 || v >= 16) throw; + const char* names[] = { "STRAIGHT_RUN_STAIR","TWO_STRAIGHT_RUN_STAIR","QUARTER_WINDING_STAIR","QUARTER_TURN_STAIR","HALF_WINDING_STAIR","HALF_TURN_STAIR","TWO_QUARTER_WINDING_STAIR","TWO_QUARTER_TURN_STAIR","THREE_QUARTER_WINDING_STAIR","THREE_QUARTER_TURN_STAIR","SPIRAL_STAIR","DOUBLE_RETURN_STAIR","CURVED_RUN_STAIR","TWO_CURVED_RUN_STAIR","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcStateEnum::ToString(IfcStateEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "READWRITE","READONLY","LOCKED","READWRITELOCKED","READONLYLOCKED" }; + return names[v]; +} +std::string IfcStructuralCurveTypeEnum::ToString(IfcStructuralCurveTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "RIGID_JOINED_MEMBER","PIN_JOINED_MEMBER","CABLE","TENSION_MEMBER","COMPRESSION_MEMBER","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcStructuralSurfaceTypeEnum::ToString(IfcStructuralSurfaceTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "BENDING_ELEMENT","MEMBRANE_ELEMENT","SHELL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcSurfaceSide::ToString(IfcSurfaceSide v) { + if (v < 0 || v >= 3) throw; + const char* names[] = { "POSITIVE","NEGATIVE","BOTH" }; + return names[v]; +} +std::string IfcSurfaceTextureEnum::ToString(IfcSurfaceTextureEnum v) { + if (v < 0 || v >= 9) throw; + const char* names[] = { "BUMP","OPACITY","REFLECTION","SELFILLUMINATION","SHININESS","SPECULAR","TEXTURE","TRANSPARENCYMAP","NOTDEFINED" }; + return names[v]; +} +std::string IfcSwitchingDeviceTypeEnum::ToString(IfcSwitchingDeviceTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "CONTACTOR","EMERGENCYSTOP","STARTER","SWITCHDISCONNECTOR","TOGGLESWITCH","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcTankTypeEnum::ToString(IfcTankTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "PREFORMED","SECTIONAL","EXPANSION","PRESSUREVESSEL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcTendonTypeEnum::ToString(IfcTendonTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "STRAND","WIRE","BAR","COATED","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcTextPath::ToString(IfcTextPath v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "LEFT","RIGHT","UP","DOWN" }; + return names[v]; +} +std::string IfcThermalLoadSourceEnum::ToString(IfcThermalLoadSourceEnum v) { + if (v < 0 || v >= 13) throw; + const char* names[] = { "PEOPLE","LIGHTING","EQUIPMENT","VENTILATIONINDOORAIR","VENTILATIONOUTSIDEAIR","RECIRCULATEDAIR","EXHAUSTAIR","AIREXCHANGERATE","DRYBULBTEMPERATURE","RELATIVEHUMIDITY","INFILTRATION","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcThermalLoadTypeEnum::ToString(IfcThermalLoadTypeEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "SENSIBLE","LATENT","RADIANT","NOTDEFINED" }; + return names[v]; +} +std::string IfcTimeSeriesDataTypeEnum::ToString(IfcTimeSeriesDataTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "CONTINUOUS","DISCRETE","DISCRETEBINARY","PIECEWISEBINARY","PIECEWISECONSTANT","PIECEWISECONTINUOUS","NOTDEFINED" }; + return names[v]; +} +std::string IfcTimeSeriesScheduleTypeEnum::ToString(IfcTimeSeriesScheduleTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "ANNUAL","MONTHLY","WEEKLY","DAILY","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcTransformerTypeEnum::ToString(IfcTransformerTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "CURRENT","FREQUENCY","VOLTAGE","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcTransitionCode::ToString(IfcTransitionCode v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "DISCONTINUOUS","CONTINUOUS","CONTSAMEGRADIENT","CONTSAMEGRADIENTSAMECURVATURE" }; + return names[v]; +} +std::string IfcTransportElementTypeEnum::ToString(IfcTransportElementTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "ELEVATOR","ESCALATOR","MOVINGWALKWAY","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcTrimmingPreference::ToString(IfcTrimmingPreference v) { + if (v < 0 || v >= 3) throw; + const char* names[] = { "CARTESIAN","PARAMETER","UNSPECIFIED" }; + return names[v]; +} +std::string IfcTubeBundleTypeEnum::ToString(IfcTubeBundleTypeEnum v) { + if (v < 0 || v >= 3) throw; + const char* names[] = { "FINNED","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcUnitEnum::ToString(IfcUnitEnum v) { + if (v < 0 || v >= 30) throw; + const char* names[] = { "ABSORBEDDOSEUNIT","AMOUNTOFSUBSTANCEUNIT","AREAUNIT","DOSEEQUIVALENTUNIT","ELECTRICCAPACITANCEUNIT","ELECTRICCHARGEUNIT","ELECTRICCONDUCTANCEUNIT","ELECTRICCURRENTUNIT","ELECTRICRESISTANCEUNIT","ELECTRICVOLTAGEUNIT","ENERGYUNIT","FORCEUNIT","FREQUENCYUNIT","ILLUMINANCEUNIT","INDUCTANCEUNIT","LENGTHUNIT","LUMINOUSFLUXUNIT","LUMINOUSINTENSITYUNIT","MAGNETICFLUXDENSITYUNIT","MAGNETICFLUXUNIT","MASSUNIT","PLANEANGLEUNIT","POWERUNIT","PRESSUREUNIT","RADIOACTIVITYUNIT","SOLIDANGLEUNIT","THERMODYNAMICTEMPERATUREUNIT","TIMEUNIT","VOLUMEUNIT","USERDEFINED" }; + return names[v]; +} +std::string IfcUnitaryEquipmentTypeEnum::ToString(IfcUnitaryEquipmentTypeEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "AIRHANDLER","AIRCONDITIONINGUNIT","SPLITSYSTEM","ROOFTOPUNIT","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcValveTypeEnum::ToString(IfcValveTypeEnum v) { + if (v < 0 || v >= 23) throw; + const char* names[] = { "AIRRELEASE","ANTIVACUUM","CHANGEOVER","CHECK","COMMISSIONING","DIVERTING","DRAWOFFCOCK","DOUBLECHECK","DOUBLEREGULATING","FAUCET","FLUSHING","GASCOCK","GASTAP","ISOLATING","MIXING","PRESSUREREDUCING","PRESSURERELIEF","REGULATING","SAFETYCUTOFF","STEAMTRAP","STOPCOCK","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcVibrationIsolatorTypeEnum::ToString(IfcVibrationIsolatorTypeEnum v) { + if (v < 0 || v >= 4) throw; + const char* names[] = { "COMPRESSION","SPRING","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcWallTypeEnum::ToString(IfcWallTypeEnum v) { + if (v < 0 || v >= 7) throw; + const char* names[] = { "STANDARD","POLYGONAL","SHEAR","ELEMENTEDWALL","PLUMBINGWALL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcWasteTerminalTypeEnum::ToString(IfcWasteTerminalTypeEnum v) { + if (v < 0 || v >= 12) throw; + const char* names[] = { "FLOORTRAP","FLOORWASTE","GULLYSUMP","GULLYTRAP","GREASEINTERCEPTOR","OILINTERCEPTOR","PETROLINTERCEPTOR","ROOFDRAIN","WASTEDISPOSALUNIT","WASTETRAP","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcWindowPanelOperationEnum::ToString(IfcWindowPanelOperationEnum v) { + if (v < 0 || v >= 14) throw; + const char* names[] = { "SIDEHUNGRIGHTHAND","SIDEHUNGLEFTHAND","TILTANDTURNRIGHTHAND","TILTANDTURNLEFTHAND","TOPHUNG","BOTTOMHUNG","PIVOTHORIZONTAL","PIVOTVERTICAL","SLIDINGHORIZONTAL","SLIDINGVERTICAL","REMOVABLECASEMENT","FIXEDCASEMENT","OTHEROPERATION","NOTDEFINED" }; + return names[v]; +} +std::string IfcWindowPanelPositionEnum::ToString(IfcWindowPanelPositionEnum v) { + if (v < 0 || v >= 6) throw; + const char* names[] = { "LEFT","MIDDLE","RIGHT","BOTTOM","TOP","NOTDEFINED" }; + return names[v]; +} +std::string IfcWindowStyleConstructionEnum::ToString(IfcWindowStyleConstructionEnum v) { + if (v < 0 || v >= 8) throw; + const char* names[] = { "ALUMINIUM","HIGH_GRADE_STEEL","STEEL","WOOD","ALUMINIUM_WOOD","PLASTIC","OTHER_CONSTRUCTION","NOTDEFINED" }; + return names[v]; +} +std::string IfcWindowStyleOperationEnum::ToString(IfcWindowStyleOperationEnum v) { + if (v < 0 || v >= 11) throw; + const char* names[] = { "SINGLE_PANEL","DOUBLE_PANEL_VERTICAL","DOUBLE_PANEL_HORIZONTAL","TRIPLE_PANEL_VERTICAL","TRIPLE_PANEL_BOTTOM","TRIPLE_PANEL_TOP","TRIPLE_PANEL_LEFT","TRIPLE_PANEL_RIGHT","TRIPLE_PANEL_HORIZONTAL","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +std::string IfcWorkControlTypeEnum::ToString(IfcWorkControlTypeEnum v) { + if (v < 0 || v >= 5) throw; + const char* names[] = { "ACTUAL","BASELINE","PLANNED","USERDEFINED","NOTDEFINED" }; + return names[v]; +} +IfcActionSourceTypeEnum::IfcActionSourceTypeEnum IfcActionSourceTypeEnum::FromString(const std::string& s){ + if (s=="DEAD_LOAD_G" ) return IfcActionSourceTypeEnum::DEAD_LOAD_G; + else if(s=="COMPLETION_G1" ) return IfcActionSourceTypeEnum::COMPLETION_G1; + else if(s=="LIVE_LOAD_Q" ) return IfcActionSourceTypeEnum::LIVE_LOAD_Q; + else if(s=="SNOW_S" ) return IfcActionSourceTypeEnum::SNOW_S; + else if(s=="WIND_W" ) return IfcActionSourceTypeEnum::WIND_W; + else if(s=="PRESTRESSING_P" ) return IfcActionSourceTypeEnum::PRESTRESSING_P; + else if(s=="SETTLEMENT_U" ) return IfcActionSourceTypeEnum::SETTLEMENT_U; + else if(s=="TEMPERATURE_T" ) return IfcActionSourceTypeEnum::TEMPERATURE_T; + else if(s=="EARTHQUAKE_E" ) return IfcActionSourceTypeEnum::EARTHQUAKE_E; + else if(s=="FIRE" ) return IfcActionSourceTypeEnum::FIRE; + else if(s=="IMPULSE" ) return IfcActionSourceTypeEnum::IMPULSE; + else if(s=="IMPACT" ) return IfcActionSourceTypeEnum::IMPACT; + else if(s=="TRANSPORT" ) return IfcActionSourceTypeEnum::TRANSPORT; + else if(s=="ERECTION" ) return IfcActionSourceTypeEnum::ERECTION; + else if(s=="PROPPING" ) return IfcActionSourceTypeEnum::PROPPING; + else if(s=="SYSTEM_IMPERFECTION") return IfcActionSourceTypeEnum::SYSTEM_IMPERFECTION; + else if(s=="SHRINKAGE" ) return IfcActionSourceTypeEnum::SHRINKAGE; + else if(s=="CREEP" ) return IfcActionSourceTypeEnum::CREEP; + else if(s=="LACK_OF_FIT" ) return IfcActionSourceTypeEnum::LACK_OF_FIT; + else if(s=="BUOYANCY" ) return IfcActionSourceTypeEnum::BUOYANCY; + else if(s=="ICE" ) return IfcActionSourceTypeEnum::ICE; + else if(s=="CURRENT" ) return IfcActionSourceTypeEnum::CURRENT; + else if(s=="WAVE" ) return IfcActionSourceTypeEnum::WAVE; + else if(s=="RAIN" ) return IfcActionSourceTypeEnum::RAIN; + else if(s=="BRAKES" ) return IfcActionSourceTypeEnum::BRAKES; + else if(s=="USERDEFINED" ) return IfcActionSourceTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcActionSourceTypeEnum::NOTDEFINED; + else throw; +} +IfcActionTypeEnum::IfcActionTypeEnum IfcActionTypeEnum::FromString(const std::string& s){ + if (s=="PERMANENT_G" ) return IfcActionTypeEnum::PERMANENT_G; + else if(s=="VARIABLE_Q" ) return IfcActionTypeEnum::VARIABLE_Q; + else if(s=="EXTRAORDINARY_A") return IfcActionTypeEnum::EXTRAORDINARY_A; + else if(s=="USERDEFINED" ) return IfcActionTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcActionTypeEnum::NOTDEFINED; + else throw; +} +IfcActuatorTypeEnum::IfcActuatorTypeEnum IfcActuatorTypeEnum::FromString(const std::string& s){ + if (s=="ELECTRICACTUATOR" ) return IfcActuatorTypeEnum::ELECTRICACTUATOR; + else if(s=="HANDOPERATEDACTUATOR") return IfcActuatorTypeEnum::HANDOPERATEDACTUATOR; + else if(s=="HYDRAULICACTUATOR" ) return IfcActuatorTypeEnum::HYDRAULICACTUATOR; + else if(s=="PNEUMATICACTUATOR" ) return IfcActuatorTypeEnum::PNEUMATICACTUATOR; + else if(s=="THERMOSTATICACTUATOR") return IfcActuatorTypeEnum::THERMOSTATICACTUATOR; + else if(s=="USERDEFINED" ) return IfcActuatorTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcActuatorTypeEnum::NOTDEFINED; + else throw; +} +IfcAddressTypeEnum::IfcAddressTypeEnum IfcAddressTypeEnum::FromString(const std::string& s){ + if (s=="OFFICE" ) return IfcAddressTypeEnum::OFFICE; + else if(s=="SITE" ) return IfcAddressTypeEnum::SITE; + else if(s=="HOME" ) return IfcAddressTypeEnum::HOME; + else if(s=="DISTRIBUTIONPOINT") return IfcAddressTypeEnum::DISTRIBUTIONPOINT; + else if(s=="USERDEFINED" ) return IfcAddressTypeEnum::USERDEFINED; + else throw; +} +IfcAheadOrBehind::IfcAheadOrBehind IfcAheadOrBehind::FromString(const std::string& s){ + if (s=="AHEAD" ) return IfcAheadOrBehind::AHEAD; + else if(s=="BEHIND") return IfcAheadOrBehind::BEHIND; + else throw; +} +IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum IfcAirTerminalBoxTypeEnum::FromString(const std::string& s){ + if (s=="CONSTANTFLOW" ) return IfcAirTerminalBoxTypeEnum::CONSTANTFLOW; + else if(s=="VARIABLEFLOWPRESSUREDEPENDANT" ) return IfcAirTerminalBoxTypeEnum::VARIABLEFLOWPRESSUREDEPENDANT; + else if(s=="VARIABLEFLOWPRESSUREINDEPENDANT") return IfcAirTerminalBoxTypeEnum::VARIABLEFLOWPRESSUREINDEPENDANT; + else if(s=="USERDEFINED" ) return IfcAirTerminalBoxTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcAirTerminalBoxTypeEnum::NOTDEFINED; + else throw; +} +IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum IfcAirTerminalTypeEnum::FromString(const std::string& s){ + if (s=="GRILLE" ) return IfcAirTerminalTypeEnum::GRILLE; + else if(s=="REGISTER" ) return IfcAirTerminalTypeEnum::REGISTER; + else if(s=="DIFFUSER" ) return IfcAirTerminalTypeEnum::DIFFUSER; + else if(s=="EYEBALL" ) return IfcAirTerminalTypeEnum::EYEBALL; + else if(s=="IRIS" ) return IfcAirTerminalTypeEnum::IRIS; + else if(s=="LINEARGRILLE" ) return IfcAirTerminalTypeEnum::LINEARGRILLE; + else if(s=="LINEARDIFFUSER") return IfcAirTerminalTypeEnum::LINEARDIFFUSER; + else if(s=="USERDEFINED" ) return IfcAirTerminalTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcAirTerminalTypeEnum::NOTDEFINED; + else throw; +} +IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum IfcAirToAirHeatRecoveryTypeEnum::FromString(const std::string& s){ + if (s=="FIXEDPLATECOUNTERFLOWEXCHANGER" ) return IfcAirToAirHeatRecoveryTypeEnum::FIXEDPLATECOUNTERFLOWEXCHANGER; + else if(s=="FIXEDPLATECROSSFLOWEXCHANGER" ) return IfcAirToAirHeatRecoveryTypeEnum::FIXEDPLATECROSSFLOWEXCHANGER; + else if(s=="FIXEDPLATEPARALLELFLOWEXCHANGER" ) return IfcAirToAirHeatRecoveryTypeEnum::FIXEDPLATEPARALLELFLOWEXCHANGER; + else if(s=="ROTARYWHEEL" ) return IfcAirToAirHeatRecoveryTypeEnum::ROTARYWHEEL; + else if(s=="RUNAROUNDCOILLOOP" ) return IfcAirToAirHeatRecoveryTypeEnum::RUNAROUNDCOILLOOP; + else if(s=="HEATPIPE" ) return IfcAirToAirHeatRecoveryTypeEnum::HEATPIPE; + else if(s=="TWINTOWERENTHALPYRECOVERYLOOPS" ) return IfcAirToAirHeatRecoveryTypeEnum::TWINTOWERENTHALPYRECOVERYLOOPS; + else if(s=="THERMOSIPHONSEALEDTUBEHEATEXCHANGERS") return IfcAirToAirHeatRecoveryTypeEnum::THERMOSIPHONSEALEDTUBEHEATEXCHANGERS; + else if(s=="THERMOSIPHONCOILTYPEHEATEXCHANGERS" ) return IfcAirToAirHeatRecoveryTypeEnum::THERMOSIPHONCOILTYPEHEATEXCHANGERS; + else if(s=="USERDEFINED" ) return IfcAirToAirHeatRecoveryTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcAirToAirHeatRecoveryTypeEnum::NOTDEFINED; + else throw; +} +IfcAlarmTypeEnum::IfcAlarmTypeEnum IfcAlarmTypeEnum::FromString(const std::string& s){ + if (s=="BELL" ) return IfcAlarmTypeEnum::BELL; + else if(s=="BREAKGLASSBUTTON") return IfcAlarmTypeEnum::BREAKGLASSBUTTON; + else if(s=="LIGHT" ) return IfcAlarmTypeEnum::LIGHT; + else if(s=="MANUALPULLBOX" ) return IfcAlarmTypeEnum::MANUALPULLBOX; + else if(s=="SIREN" ) return IfcAlarmTypeEnum::SIREN; + else if(s=="WHISTLE" ) return IfcAlarmTypeEnum::WHISTLE; + else if(s=="USERDEFINED" ) return IfcAlarmTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcAlarmTypeEnum::NOTDEFINED; + else throw; +} +IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum IfcAnalysisModelTypeEnum::FromString(const std::string& s){ + if (s=="IN_PLANE_LOADING_2D" ) return IfcAnalysisModelTypeEnum::IN_PLANE_LOADING_2D; + else if(s=="OUT_PLANE_LOADING_2D") return IfcAnalysisModelTypeEnum::OUT_PLANE_LOADING_2D; + else if(s=="LOADING_3D" ) return IfcAnalysisModelTypeEnum::LOADING_3D; + else if(s=="USERDEFINED" ) return IfcAnalysisModelTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcAnalysisModelTypeEnum::NOTDEFINED; + else throw; +} +IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum IfcAnalysisTheoryTypeEnum::FromString(const std::string& s){ + if (s=="FIRST_ORDER_THEORY" ) return IfcAnalysisTheoryTypeEnum::FIRST_ORDER_THEORY; + else if(s=="SECOND_ORDER_THEORY" ) return IfcAnalysisTheoryTypeEnum::SECOND_ORDER_THEORY; + else if(s=="THIRD_ORDER_THEORY" ) return IfcAnalysisTheoryTypeEnum::THIRD_ORDER_THEORY; + else if(s=="FULL_NONLINEAR_THEORY") return IfcAnalysisTheoryTypeEnum::FULL_NONLINEAR_THEORY; + else if(s=="USERDEFINED" ) return IfcAnalysisTheoryTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcAnalysisTheoryTypeEnum::NOTDEFINED; + else throw; +} +IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum IfcArithmeticOperatorEnum::FromString(const std::string& s){ + if (s=="ADD" ) return IfcArithmeticOperatorEnum::ADD; + else if(s=="DIVIDE" ) return IfcArithmeticOperatorEnum::DIVIDE; + else if(s=="MULTIPLY") return IfcArithmeticOperatorEnum::MULTIPLY; + else if(s=="SUBTRACT") return IfcArithmeticOperatorEnum::SUBTRACT; + else throw; +} +IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum IfcAssemblyPlaceEnum::FromString(const std::string& s){ + if (s=="SITE" ) return IfcAssemblyPlaceEnum::SITE; + else if(s=="FACTORY" ) return IfcAssemblyPlaceEnum::FACTORY; + else if(s=="NOTDEFINED") return IfcAssemblyPlaceEnum::NOTDEFINED; + else throw; +} +IfcBSplineCurveForm::IfcBSplineCurveForm IfcBSplineCurveForm::FromString(const std::string& s){ + if (s=="POLYLINE_FORM" ) return IfcBSplineCurveForm::POLYLINE_FORM; + else if(s=="CIRCULAR_ARC" ) return IfcBSplineCurveForm::CIRCULAR_ARC; + else if(s=="ELLIPTIC_ARC" ) return IfcBSplineCurveForm::ELLIPTIC_ARC; + else if(s=="PARABOLIC_ARC" ) return IfcBSplineCurveForm::PARABOLIC_ARC; + else if(s=="HYPERBOLIC_ARC") return IfcBSplineCurveForm::HYPERBOLIC_ARC; + else if(s=="UNSPECIFIED" ) return IfcBSplineCurveForm::UNSPECIFIED; + else throw; +} +IfcBeamTypeEnum::IfcBeamTypeEnum IfcBeamTypeEnum::FromString(const std::string& s){ + if (s=="BEAM" ) return IfcBeamTypeEnum::BEAM; + else if(s=="JOIST" ) return IfcBeamTypeEnum::JOIST; + else if(s=="LINTEL" ) return IfcBeamTypeEnum::LINTEL; + else if(s=="T_BEAM" ) return IfcBeamTypeEnum::T_BEAM; + else if(s=="USERDEFINED") return IfcBeamTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcBeamTypeEnum::NOTDEFINED; + else throw; +} +IfcBenchmarkEnum::IfcBenchmarkEnum IfcBenchmarkEnum::FromString(const std::string& s){ + if (s=="GREATERTHAN" ) return IfcBenchmarkEnum::GREATERTHAN; + else if(s=="GREATERTHANOREQUALTO") return IfcBenchmarkEnum::GREATERTHANOREQUALTO; + else if(s=="LESSTHAN" ) return IfcBenchmarkEnum::LESSTHAN; + else if(s=="LESSTHANOREQUALTO" ) return IfcBenchmarkEnum::LESSTHANOREQUALTO; + else if(s=="EQUALTO" ) return IfcBenchmarkEnum::EQUALTO; + else if(s=="NOTEQUALTO" ) return IfcBenchmarkEnum::NOTEQUALTO; + else throw; +} +IfcBoilerTypeEnum::IfcBoilerTypeEnum IfcBoilerTypeEnum::FromString(const std::string& s){ + if (s=="WATER" ) return IfcBoilerTypeEnum::WATER; + else if(s=="STEAM" ) return IfcBoilerTypeEnum::STEAM; + else if(s=="USERDEFINED") return IfcBoilerTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcBoilerTypeEnum::NOTDEFINED; + else throw; +} +IfcBooleanOperator::IfcBooleanOperator IfcBooleanOperator::FromString(const std::string& s){ + if (s=="UNION" ) return IfcBooleanOperator::UNION; + else if(s=="INTERSECTION") return IfcBooleanOperator::INTERSECTION; + else if(s=="DIFFERENCE" ) return IfcBooleanOperator::DIFFERENCE; + else throw; +} +IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum IfcBuildingElementProxyTypeEnum::FromString(const std::string& s){ + if (s=="USERDEFINED") return IfcBuildingElementProxyTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcBuildingElementProxyTypeEnum::NOTDEFINED; + else throw; +} +IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum IfcCableCarrierFittingTypeEnum::FromString(const std::string& s){ + if (s=="BEND" ) return IfcCableCarrierFittingTypeEnum::BEND; + else if(s=="CROSS" ) return IfcCableCarrierFittingTypeEnum::CROSS; + else if(s=="REDUCER" ) return IfcCableCarrierFittingTypeEnum::REDUCER; + else if(s=="TEE" ) return IfcCableCarrierFittingTypeEnum::TEE; + else if(s=="USERDEFINED") return IfcCableCarrierFittingTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcCableCarrierFittingTypeEnum::NOTDEFINED; + else throw; +} +IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum IfcCableCarrierSegmentTypeEnum::FromString(const std::string& s){ + if (s=="CABLELADDERSEGMENT" ) return IfcCableCarrierSegmentTypeEnum::CABLELADDERSEGMENT; + else if(s=="CABLETRAYSEGMENT" ) return IfcCableCarrierSegmentTypeEnum::CABLETRAYSEGMENT; + else if(s=="CABLETRUNKINGSEGMENT") return IfcCableCarrierSegmentTypeEnum::CABLETRUNKINGSEGMENT; + else if(s=="CONDUITSEGMENT" ) return IfcCableCarrierSegmentTypeEnum::CONDUITSEGMENT; + else if(s=="USERDEFINED" ) return IfcCableCarrierSegmentTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcCableCarrierSegmentTypeEnum::NOTDEFINED; + else throw; +} +IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum IfcCableSegmentTypeEnum::FromString(const std::string& s){ + if (s=="CABLESEGMENT" ) return IfcCableSegmentTypeEnum::CABLESEGMENT; + else if(s=="CONDUCTORSEGMENT") return IfcCableSegmentTypeEnum::CONDUCTORSEGMENT; + else if(s=="USERDEFINED" ) return IfcCableSegmentTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcCableSegmentTypeEnum::NOTDEFINED; + else throw; +} +IfcChangeActionEnum::IfcChangeActionEnum IfcChangeActionEnum::FromString(const std::string& s){ + if (s=="NOCHANGE" ) return IfcChangeActionEnum::NOCHANGE; + else if(s=="MODIFIED" ) return IfcChangeActionEnum::MODIFIED; + else if(s=="ADDED" ) return IfcChangeActionEnum::ADDED; + else if(s=="DELETED" ) return IfcChangeActionEnum::DELETED; + else if(s=="MODIFIEDADDED" ) return IfcChangeActionEnum::MODIFIEDADDED; + else if(s=="MODIFIEDDELETED") return IfcChangeActionEnum::MODIFIEDDELETED; + else throw; +} +IfcChillerTypeEnum::IfcChillerTypeEnum IfcChillerTypeEnum::FromString(const std::string& s){ + if (s=="AIRCOOLED" ) return IfcChillerTypeEnum::AIRCOOLED; + else if(s=="WATERCOOLED" ) return IfcChillerTypeEnum::WATERCOOLED; + else if(s=="HEATRECOVERY") return IfcChillerTypeEnum::HEATRECOVERY; + else if(s=="USERDEFINED" ) return IfcChillerTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcChillerTypeEnum::NOTDEFINED; + else throw; +} +IfcCoilTypeEnum::IfcCoilTypeEnum IfcCoilTypeEnum::FromString(const std::string& s){ + if (s=="DXCOOLINGCOIL" ) return IfcCoilTypeEnum::DXCOOLINGCOIL; + else if(s=="WATERCOOLINGCOIL" ) return IfcCoilTypeEnum::WATERCOOLINGCOIL; + else if(s=="STEAMHEATINGCOIL" ) return IfcCoilTypeEnum::STEAMHEATINGCOIL; + else if(s=="WATERHEATINGCOIL" ) return IfcCoilTypeEnum::WATERHEATINGCOIL; + else if(s=="ELECTRICHEATINGCOIL") return IfcCoilTypeEnum::ELECTRICHEATINGCOIL; + else if(s=="GASHEATINGCOIL" ) return IfcCoilTypeEnum::GASHEATINGCOIL; + else if(s=="USERDEFINED" ) return IfcCoilTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcCoilTypeEnum::NOTDEFINED; + else throw; +} +IfcColumnTypeEnum::IfcColumnTypeEnum IfcColumnTypeEnum::FromString(const std::string& s){ + if (s=="COLUMN" ) return IfcColumnTypeEnum::COLUMN; + else if(s=="USERDEFINED") return IfcColumnTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcColumnTypeEnum::NOTDEFINED; + else throw; +} +IfcCompressorTypeEnum::IfcCompressorTypeEnum IfcCompressorTypeEnum::FromString(const std::string& s){ + if (s=="DYNAMIC" ) return IfcCompressorTypeEnum::DYNAMIC; + else if(s=="RECIPROCATING" ) return IfcCompressorTypeEnum::RECIPROCATING; + else if(s=="ROTARY" ) return IfcCompressorTypeEnum::ROTARY; + else if(s=="SCROLL" ) return IfcCompressorTypeEnum::SCROLL; + else if(s=="TROCHOIDAL" ) return IfcCompressorTypeEnum::TROCHOIDAL; + else if(s=="SINGLESTAGE" ) return IfcCompressorTypeEnum::SINGLESTAGE; + else if(s=="BOOSTER" ) return IfcCompressorTypeEnum::BOOSTER; + else if(s=="OPENTYPE" ) return IfcCompressorTypeEnum::OPENTYPE; + else if(s=="HERMETIC" ) return IfcCompressorTypeEnum::HERMETIC; + else if(s=="SEMIHERMETIC" ) return IfcCompressorTypeEnum::SEMIHERMETIC; + else if(s=="WELDEDSHELLHERMETIC") return IfcCompressorTypeEnum::WELDEDSHELLHERMETIC; + else if(s=="ROLLINGPISTON" ) return IfcCompressorTypeEnum::ROLLINGPISTON; + else if(s=="ROTARYVANE" ) return IfcCompressorTypeEnum::ROTARYVANE; + else if(s=="SINGLESCREW" ) return IfcCompressorTypeEnum::SINGLESCREW; + else if(s=="TWINSCREW" ) return IfcCompressorTypeEnum::TWINSCREW; + else if(s=="USERDEFINED" ) return IfcCompressorTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcCompressorTypeEnum::NOTDEFINED; + else throw; +} +IfcCondenserTypeEnum::IfcCondenserTypeEnum IfcCondenserTypeEnum::FromString(const std::string& s){ + if (s=="WATERCOOLEDSHELLTUBE" ) return IfcCondenserTypeEnum::WATERCOOLEDSHELLTUBE; + else if(s=="WATERCOOLEDSHELLCOIL" ) return IfcCondenserTypeEnum::WATERCOOLEDSHELLCOIL; + else if(s=="WATERCOOLEDTUBEINTUBE" ) return IfcCondenserTypeEnum::WATERCOOLEDTUBEINTUBE; + else if(s=="WATERCOOLEDBRAZEDPLATE") return IfcCondenserTypeEnum::WATERCOOLEDBRAZEDPLATE; + else if(s=="AIRCOOLED" ) return IfcCondenserTypeEnum::AIRCOOLED; + else if(s=="EVAPORATIVECOOLED" ) return IfcCondenserTypeEnum::EVAPORATIVECOOLED; + else if(s=="USERDEFINED" ) return IfcCondenserTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcCondenserTypeEnum::NOTDEFINED; + else throw; +} +IfcConnectionTypeEnum::IfcConnectionTypeEnum IfcConnectionTypeEnum::FromString(const std::string& s){ + if (s=="ATPATH" ) return IfcConnectionTypeEnum::ATPATH; + else if(s=="ATSTART" ) return IfcConnectionTypeEnum::ATSTART; + else if(s=="ATEND" ) return IfcConnectionTypeEnum::ATEND; + else if(s=="NOTDEFINED") return IfcConnectionTypeEnum::NOTDEFINED; + else throw; +} +IfcConstraintEnum::IfcConstraintEnum IfcConstraintEnum::FromString(const std::string& s){ + if (s=="HARD" ) return IfcConstraintEnum::HARD; + else if(s=="SOFT" ) return IfcConstraintEnum::SOFT; + else if(s=="ADVISORY" ) return IfcConstraintEnum::ADVISORY; + else if(s=="USERDEFINED") return IfcConstraintEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcConstraintEnum::NOTDEFINED; + else throw; +} +IfcControllerTypeEnum::IfcControllerTypeEnum IfcControllerTypeEnum::FromString(const std::string& s){ + if (s=="FLOATING" ) return IfcControllerTypeEnum::FLOATING; + else if(s=="PROPORTIONAL" ) return IfcControllerTypeEnum::PROPORTIONAL; + else if(s=="PROPORTIONALINTEGRAL" ) return IfcControllerTypeEnum::PROPORTIONALINTEGRAL; + else if(s=="PROPORTIONALINTEGRALDERIVATIVE") return IfcControllerTypeEnum::PROPORTIONALINTEGRALDERIVATIVE; + else if(s=="TIMEDTWOPOSITION" ) return IfcControllerTypeEnum::TIMEDTWOPOSITION; + else if(s=="TWOPOSITION" ) return IfcControllerTypeEnum::TWOPOSITION; + else if(s=="USERDEFINED" ) return IfcControllerTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcControllerTypeEnum::NOTDEFINED; + else throw; +} +IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum IfcCooledBeamTypeEnum::FromString(const std::string& s){ + if (s=="ACTIVE" ) return IfcCooledBeamTypeEnum::ACTIVE; + else if(s=="PASSIVE" ) return IfcCooledBeamTypeEnum::PASSIVE; + else if(s=="USERDEFINED") return IfcCooledBeamTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcCooledBeamTypeEnum::NOTDEFINED; + else throw; +} +IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum IfcCoolingTowerTypeEnum::FromString(const std::string& s){ + if (s=="NATURALDRAFT" ) return IfcCoolingTowerTypeEnum::NATURALDRAFT; + else if(s=="MECHANICALINDUCEDDRAFT") return IfcCoolingTowerTypeEnum::MECHANICALINDUCEDDRAFT; + else if(s=="MECHANICALFORCEDDRAFT" ) return IfcCoolingTowerTypeEnum::MECHANICALFORCEDDRAFT; + else if(s=="USERDEFINED" ) return IfcCoolingTowerTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcCoolingTowerTypeEnum::NOTDEFINED; + else throw; +} +IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum IfcCostScheduleTypeEnum::FromString(const std::string& s){ + if (s=="BUDGET" ) return IfcCostScheduleTypeEnum::BUDGET; + else if(s=="COSTPLAN" ) return IfcCostScheduleTypeEnum::COSTPLAN; + else if(s=="ESTIMATE" ) return IfcCostScheduleTypeEnum::ESTIMATE; + else if(s=="TENDER" ) return IfcCostScheduleTypeEnum::TENDER; + else if(s=="PRICEDBILLOFQUANTITIES" ) return IfcCostScheduleTypeEnum::PRICEDBILLOFQUANTITIES; + else if(s=="UNPRICEDBILLOFQUANTITIES") return IfcCostScheduleTypeEnum::UNPRICEDBILLOFQUANTITIES; + else if(s=="SCHEDULEOFRATES" ) return IfcCostScheduleTypeEnum::SCHEDULEOFRATES; + else if(s=="USERDEFINED" ) return IfcCostScheduleTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcCostScheduleTypeEnum::NOTDEFINED; + else throw; +} +IfcCoveringTypeEnum::IfcCoveringTypeEnum IfcCoveringTypeEnum::FromString(const std::string& s){ + if (s=="CEILING" ) return IfcCoveringTypeEnum::CEILING; + else if(s=="FLOORING" ) return IfcCoveringTypeEnum::FLOORING; + else if(s=="CLADDING" ) return IfcCoveringTypeEnum::CLADDING; + else if(s=="ROOFING" ) return IfcCoveringTypeEnum::ROOFING; + else if(s=="INSULATION" ) return IfcCoveringTypeEnum::INSULATION; + else if(s=="MEMBRANE" ) return IfcCoveringTypeEnum::MEMBRANE; + else if(s=="SLEEVING" ) return IfcCoveringTypeEnum::SLEEVING; + else if(s=="WRAPPING" ) return IfcCoveringTypeEnum::WRAPPING; + else if(s=="USERDEFINED") return IfcCoveringTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcCoveringTypeEnum::NOTDEFINED; + else throw; +} +IfcCurrencyEnum::IfcCurrencyEnum IfcCurrencyEnum::FromString(const std::string& s){ + if (s=="AED") return IfcCurrencyEnum::AED; + else if(s=="AES") return IfcCurrencyEnum::AES; + else if(s=="ATS") return IfcCurrencyEnum::ATS; + else if(s=="AUD") return IfcCurrencyEnum::AUD; + else if(s=="BBD") return IfcCurrencyEnum::BBD; + else if(s=="BEG") return IfcCurrencyEnum::BEG; + else if(s=="BGL") return IfcCurrencyEnum::BGL; + else if(s=="BHD") return IfcCurrencyEnum::BHD; + else if(s=="BMD") return IfcCurrencyEnum::BMD; + else if(s=="BND") return IfcCurrencyEnum::BND; + else if(s=="BRL") return IfcCurrencyEnum::BRL; + else if(s=="BSD") return IfcCurrencyEnum::BSD; + else if(s=="BWP") return IfcCurrencyEnum::BWP; + else if(s=="BZD") return IfcCurrencyEnum::BZD; + else if(s=="CAD") return IfcCurrencyEnum::CAD; + else if(s=="CBD") return IfcCurrencyEnum::CBD; + else if(s=="CHF") return IfcCurrencyEnum::CHF; + else if(s=="CLP") return IfcCurrencyEnum::CLP; + else if(s=="CNY") return IfcCurrencyEnum::CNY; + else if(s=="CYS") return IfcCurrencyEnum::CYS; + else if(s=="CZK") return IfcCurrencyEnum::CZK; + else if(s=="DDP") return IfcCurrencyEnum::DDP; + else if(s=="DEM") return IfcCurrencyEnum::DEM; + else if(s=="DKK") return IfcCurrencyEnum::DKK; + else if(s=="EGL") return IfcCurrencyEnum::EGL; + else if(s=="EST") return IfcCurrencyEnum::EST; + else if(s=="EUR") return IfcCurrencyEnum::EUR; + else if(s=="FAK") return IfcCurrencyEnum::FAK; + else if(s=="FIM") return IfcCurrencyEnum::FIM; + else if(s=="FJD") return IfcCurrencyEnum::FJD; + else if(s=="FKP") return IfcCurrencyEnum::FKP; + else if(s=="FRF") return IfcCurrencyEnum::FRF; + else if(s=="GBP") return IfcCurrencyEnum::GBP; + else if(s=="GIP") return IfcCurrencyEnum::GIP; + else if(s=="GMD") return IfcCurrencyEnum::GMD; + else if(s=="GRX") return IfcCurrencyEnum::GRX; + else if(s=="HKD") return IfcCurrencyEnum::HKD; + else if(s=="HUF") return IfcCurrencyEnum::HUF; + else if(s=="ICK") return IfcCurrencyEnum::ICK; + else if(s=="IDR") return IfcCurrencyEnum::IDR; + else if(s=="ILS") return IfcCurrencyEnum::ILS; + else if(s=="INR") return IfcCurrencyEnum::INR; + else if(s=="IRP") return IfcCurrencyEnum::IRP; + else if(s=="ITL") return IfcCurrencyEnum::ITL; + else if(s=="JMD") return IfcCurrencyEnum::JMD; + else if(s=="JOD") return IfcCurrencyEnum::JOD; + else if(s=="JPY") return IfcCurrencyEnum::JPY; + else if(s=="KES") return IfcCurrencyEnum::KES; + else if(s=="KRW") return IfcCurrencyEnum::KRW; + else if(s=="KWD") return IfcCurrencyEnum::KWD; + else if(s=="KYD") return IfcCurrencyEnum::KYD; + else if(s=="LKR") return IfcCurrencyEnum::LKR; + else if(s=="LUF") return IfcCurrencyEnum::LUF; + else if(s=="MTL") return IfcCurrencyEnum::MTL; + else if(s=="MUR") return IfcCurrencyEnum::MUR; + else if(s=="MXN") return IfcCurrencyEnum::MXN; + else if(s=="MYR") return IfcCurrencyEnum::MYR; + else if(s=="NLG") return IfcCurrencyEnum::NLG; + else if(s=="NZD") return IfcCurrencyEnum::NZD; + else if(s=="OMR") return IfcCurrencyEnum::OMR; + else if(s=="PGK") return IfcCurrencyEnum::PGK; + else if(s=="PHP") return IfcCurrencyEnum::PHP; + else if(s=="PKR") return IfcCurrencyEnum::PKR; + else if(s=="PLN") return IfcCurrencyEnum::PLN; + else if(s=="PTN") return IfcCurrencyEnum::PTN; + else if(s=="QAR") return IfcCurrencyEnum::QAR; + else if(s=="RUR") return IfcCurrencyEnum::RUR; + else if(s=="SAR") return IfcCurrencyEnum::SAR; + else if(s=="SCR") return IfcCurrencyEnum::SCR; + else if(s=="SEK") return IfcCurrencyEnum::SEK; + else if(s=="SGD") return IfcCurrencyEnum::SGD; + else if(s=="SKP") return IfcCurrencyEnum::SKP; + else if(s=="THB") return IfcCurrencyEnum::THB; + else if(s=="TRL") return IfcCurrencyEnum::TRL; + else if(s=="TTD") return IfcCurrencyEnum::TTD; + else if(s=="TWD") return IfcCurrencyEnum::TWD; + else if(s=="USD") return IfcCurrencyEnum::USD; + else if(s=="VEB") return IfcCurrencyEnum::VEB; + else if(s=="VND") return IfcCurrencyEnum::VND; + else if(s=="XEU") return IfcCurrencyEnum::XEU; + else if(s=="ZAR") return IfcCurrencyEnum::ZAR; + else if(s=="ZWD") return IfcCurrencyEnum::ZWD; + else if(s=="NOK") return IfcCurrencyEnum::NOK; + else throw; +} +IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum IfcCurtainWallTypeEnum::FromString(const std::string& s){ + if (s=="USERDEFINED") return IfcCurtainWallTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcCurtainWallTypeEnum::NOTDEFINED; + else throw; +} +IfcDamperTypeEnum::IfcDamperTypeEnum IfcDamperTypeEnum::FromString(const std::string& s){ + if (s=="CONTROLDAMPER" ) return IfcDamperTypeEnum::CONTROLDAMPER; + else if(s=="FIREDAMPER" ) return IfcDamperTypeEnum::FIREDAMPER; + else if(s=="SMOKEDAMPER" ) return IfcDamperTypeEnum::SMOKEDAMPER; + else if(s=="FIRESMOKEDAMPER" ) return IfcDamperTypeEnum::FIRESMOKEDAMPER; + else if(s=="BACKDRAFTDAMPER" ) return IfcDamperTypeEnum::BACKDRAFTDAMPER; + else if(s=="RELIEFDAMPER" ) return IfcDamperTypeEnum::RELIEFDAMPER; + else if(s=="BLASTDAMPER" ) return IfcDamperTypeEnum::BLASTDAMPER; + else if(s=="GRAVITYDAMPER" ) return IfcDamperTypeEnum::GRAVITYDAMPER; + else if(s=="GRAVITYRELIEFDAMPER") return IfcDamperTypeEnum::GRAVITYRELIEFDAMPER; + else if(s=="BALANCINGDAMPER" ) return IfcDamperTypeEnum::BALANCINGDAMPER; + else if(s=="FUMEHOODEXHAUST" ) return IfcDamperTypeEnum::FUMEHOODEXHAUST; + else if(s=="USERDEFINED" ) return IfcDamperTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcDamperTypeEnum::NOTDEFINED; + else throw; +} +IfcDataOriginEnum::IfcDataOriginEnum IfcDataOriginEnum::FromString(const std::string& s){ + if (s=="MEASURED" ) return IfcDataOriginEnum::MEASURED; + else if(s=="PREDICTED" ) return IfcDataOriginEnum::PREDICTED; + else if(s=="SIMULATED" ) return IfcDataOriginEnum::SIMULATED; + else if(s=="USERDEFINED") return IfcDataOriginEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcDataOriginEnum::NOTDEFINED; + else throw; +} +IfcDerivedUnitEnum::IfcDerivedUnitEnum IfcDerivedUnitEnum::FromString(const std::string& s){ + if (s=="ANGULARVELOCITYUNIT" ) return IfcDerivedUnitEnum::ANGULARVELOCITYUNIT; + else if(s=="COMPOUNDPLANEANGLEUNIT" ) return IfcDerivedUnitEnum::COMPOUNDPLANEANGLEUNIT; + else if(s=="DYNAMICVISCOSITYUNIT" ) return IfcDerivedUnitEnum::DYNAMICVISCOSITYUNIT; + else if(s=="HEATFLUXDENSITYUNIT" ) return IfcDerivedUnitEnum::HEATFLUXDENSITYUNIT; + else if(s=="INTEGERCOUNTRATEUNIT" ) return IfcDerivedUnitEnum::INTEGERCOUNTRATEUNIT; + else if(s=="ISOTHERMALMOISTURECAPACITYUNIT" ) return IfcDerivedUnitEnum::ISOTHERMALMOISTURECAPACITYUNIT; + else if(s=="KINEMATICVISCOSITYUNIT" ) return IfcDerivedUnitEnum::KINEMATICVISCOSITYUNIT; + else if(s=="LINEARVELOCITYUNIT" ) return IfcDerivedUnitEnum::LINEARVELOCITYUNIT; + else if(s=="MASSDENSITYUNIT" ) return IfcDerivedUnitEnum::MASSDENSITYUNIT; + else if(s=="MASSFLOWRATEUNIT" ) return IfcDerivedUnitEnum::MASSFLOWRATEUNIT; + else if(s=="MOISTUREDIFFUSIVITYUNIT" ) return IfcDerivedUnitEnum::MOISTUREDIFFUSIVITYUNIT; + else if(s=="MOLECULARWEIGHTUNIT" ) return IfcDerivedUnitEnum::MOLECULARWEIGHTUNIT; + else if(s=="SPECIFICHEATCAPACITYUNIT" ) return IfcDerivedUnitEnum::SPECIFICHEATCAPACITYUNIT; + else if(s=="THERMALADMITTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALADMITTANCEUNIT; + else if(s=="THERMALCONDUCTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALCONDUCTANCEUNIT; + else if(s=="THERMALRESISTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALRESISTANCEUNIT; + else if(s=="THERMALTRANSMITTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALTRANSMITTANCEUNIT; + else if(s=="VAPORPERMEABILITYUNIT" ) return IfcDerivedUnitEnum::VAPORPERMEABILITYUNIT; + else if(s=="VOLUMETRICFLOWRATEUNIT" ) return IfcDerivedUnitEnum::VOLUMETRICFLOWRATEUNIT; + else if(s=="ROTATIONALFREQUENCYUNIT" ) return IfcDerivedUnitEnum::ROTATIONALFREQUENCYUNIT; + else if(s=="TORQUEUNIT" ) return IfcDerivedUnitEnum::TORQUEUNIT; + else if(s=="MOMENTOFINERTIAUNIT" ) return IfcDerivedUnitEnum::MOMENTOFINERTIAUNIT; + else if(s=="LINEARMOMENTUNIT" ) return IfcDerivedUnitEnum::LINEARMOMENTUNIT; + else if(s=="LINEARFORCEUNIT" ) return IfcDerivedUnitEnum::LINEARFORCEUNIT; + else if(s=="PLANARFORCEUNIT" ) return IfcDerivedUnitEnum::PLANARFORCEUNIT; + else if(s=="MODULUSOFELASTICITYUNIT" ) return IfcDerivedUnitEnum::MODULUSOFELASTICITYUNIT; + else if(s=="SHEARMODULUSUNIT" ) return IfcDerivedUnitEnum::SHEARMODULUSUNIT; + else if(s=="LINEARSTIFFNESSUNIT" ) return IfcDerivedUnitEnum::LINEARSTIFFNESSUNIT; + else if(s=="ROTATIONALSTIFFNESSUNIT" ) return IfcDerivedUnitEnum::ROTATIONALSTIFFNESSUNIT; + else if(s=="MODULUSOFSUBGRADEREACTIONUNIT" ) return IfcDerivedUnitEnum::MODULUSOFSUBGRADEREACTIONUNIT; + else if(s=="ACCELERATIONUNIT" ) return IfcDerivedUnitEnum::ACCELERATIONUNIT; + else if(s=="CURVATUREUNIT" ) return IfcDerivedUnitEnum::CURVATUREUNIT; + else if(s=="HEATINGVALUEUNIT" ) return IfcDerivedUnitEnum::HEATINGVALUEUNIT; + else if(s=="IONCONCENTRATIONUNIT" ) return IfcDerivedUnitEnum::IONCONCENTRATIONUNIT; + else if(s=="LUMINOUSINTENSITYDISTRIBUTIONUNIT" ) return IfcDerivedUnitEnum::LUMINOUSINTENSITYDISTRIBUTIONUNIT; + else if(s=="MASSPERLENGTHUNIT" ) return IfcDerivedUnitEnum::MASSPERLENGTHUNIT; + else if(s=="MODULUSOFLINEARSUBGRADEREACTIONUNIT" ) return IfcDerivedUnitEnum::MODULUSOFLINEARSUBGRADEREACTIONUNIT; + else if(s=="MODULUSOFROTATIONALSUBGRADEREACTIONUNIT") return IfcDerivedUnitEnum::MODULUSOFROTATIONALSUBGRADEREACTIONUNIT; + else if(s=="PHUNIT" ) return IfcDerivedUnitEnum::PHUNIT; + else if(s=="ROTATIONALMASSUNIT" ) return IfcDerivedUnitEnum::ROTATIONALMASSUNIT; + else if(s=="SECTIONAREAINTEGRALUNIT" ) return IfcDerivedUnitEnum::SECTIONAREAINTEGRALUNIT; + else if(s=="SECTIONMODULUSUNIT" ) return IfcDerivedUnitEnum::SECTIONMODULUSUNIT; + else if(s=="SOUNDPOWERUNIT" ) return IfcDerivedUnitEnum::SOUNDPOWERUNIT; + else if(s=="SOUNDPRESSUREUNIT" ) return IfcDerivedUnitEnum::SOUNDPRESSUREUNIT; + else if(s=="TEMPERATUREGRADIENTUNIT" ) return IfcDerivedUnitEnum::TEMPERATUREGRADIENTUNIT; + else if(s=="THERMALEXPANSIONCOEFFICIENTUNIT" ) return IfcDerivedUnitEnum::THERMALEXPANSIONCOEFFICIENTUNIT; + else if(s=="WARPINGCONSTANTUNIT" ) return IfcDerivedUnitEnum::WARPINGCONSTANTUNIT; + else if(s=="WARPINGMOMENTUNIT" ) return IfcDerivedUnitEnum::WARPINGMOMENTUNIT; + else if(s=="USERDEFINED" ) return IfcDerivedUnitEnum::USERDEFINED; + else throw; +} +IfcDimensionExtentUsage::IfcDimensionExtentUsage IfcDimensionExtentUsage::FromString(const std::string& s){ + if (s=="ORIGIN") return IfcDimensionExtentUsage::ORIGIN; + else if(s=="TARGET") return IfcDimensionExtentUsage::TARGET; + else throw; +} +IfcDirectionSenseEnum::IfcDirectionSenseEnum IfcDirectionSenseEnum::FromString(const std::string& s){ + if (s=="POSITIVE") return IfcDirectionSenseEnum::POSITIVE; + else if(s=="NEGATIVE") return IfcDirectionSenseEnum::NEGATIVE; + else throw; +} +IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum IfcDistributionChamberElementTypeEnum::FromString(const std::string& s){ + if (s=="FORMEDDUCT" ) return IfcDistributionChamberElementTypeEnum::FORMEDDUCT; + else if(s=="INSPECTIONCHAMBER") return IfcDistributionChamberElementTypeEnum::INSPECTIONCHAMBER; + else if(s=="INSPECTIONPIT" ) return IfcDistributionChamberElementTypeEnum::INSPECTIONPIT; + else if(s=="MANHOLE" ) return IfcDistributionChamberElementTypeEnum::MANHOLE; + else if(s=="METERCHAMBER" ) return IfcDistributionChamberElementTypeEnum::METERCHAMBER; + else if(s=="SUMP" ) return IfcDistributionChamberElementTypeEnum::SUMP; + else if(s=="TRENCH" ) return IfcDistributionChamberElementTypeEnum::TRENCH; + else if(s=="VALVECHAMBER" ) return IfcDistributionChamberElementTypeEnum::VALVECHAMBER; + else if(s=="USERDEFINED" ) return IfcDistributionChamberElementTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcDistributionChamberElementTypeEnum::NOTDEFINED; + else throw; +} +IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum IfcDocumentConfidentialityEnum::FromString(const std::string& s){ + if (s=="PUBLIC" ) return IfcDocumentConfidentialityEnum::PUBLIC; + else if(s=="RESTRICTED" ) return IfcDocumentConfidentialityEnum::RESTRICTED; + else if(s=="CONFIDENTIAL") return IfcDocumentConfidentialityEnum::CONFIDENTIAL; + else if(s=="PERSONAL" ) return IfcDocumentConfidentialityEnum::PERSONAL; + else if(s=="USERDEFINED" ) return IfcDocumentConfidentialityEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcDocumentConfidentialityEnum::NOTDEFINED; + else throw; +} +IfcDocumentStatusEnum::IfcDocumentStatusEnum IfcDocumentStatusEnum::FromString(const std::string& s){ + if (s=="DRAFT" ) return IfcDocumentStatusEnum::DRAFT; + else if(s=="FINALDRAFT") return IfcDocumentStatusEnum::FINALDRAFT; + else if(s=="FINAL" ) return IfcDocumentStatusEnum::FINAL; + else if(s=="REVISION" ) return IfcDocumentStatusEnum::REVISION; + else if(s=="NOTDEFINED") return IfcDocumentStatusEnum::NOTDEFINED; + else throw; +} +IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum IfcDoorPanelOperationEnum::FromString(const std::string& s){ + if (s=="SWINGING" ) return IfcDoorPanelOperationEnum::SWINGING; + else if(s=="DOUBLE_ACTING") return IfcDoorPanelOperationEnum::DOUBLE_ACTING; + else if(s=="SLIDING" ) return IfcDoorPanelOperationEnum::SLIDING; + else if(s=="FOLDING" ) return IfcDoorPanelOperationEnum::FOLDING; + else if(s=="REVOLVING" ) return IfcDoorPanelOperationEnum::REVOLVING; + else if(s=="ROLLINGUP" ) return IfcDoorPanelOperationEnum::ROLLINGUP; + else if(s=="USERDEFINED" ) return IfcDoorPanelOperationEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcDoorPanelOperationEnum::NOTDEFINED; + else throw; +} +IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum IfcDoorPanelPositionEnum::FromString(const std::string& s){ + if (s=="LEFT" ) return IfcDoorPanelPositionEnum::LEFT; + else if(s=="MIDDLE" ) return IfcDoorPanelPositionEnum::MIDDLE; + else if(s=="RIGHT" ) return IfcDoorPanelPositionEnum::RIGHT; + else if(s=="NOTDEFINED") return IfcDoorPanelPositionEnum::NOTDEFINED; + else throw; +} +IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum IfcDoorStyleConstructionEnum::FromString(const std::string& s){ + if (s=="ALUMINIUM" ) return IfcDoorStyleConstructionEnum::ALUMINIUM; + else if(s=="HIGH_GRADE_STEEL" ) return IfcDoorStyleConstructionEnum::HIGH_GRADE_STEEL; + else if(s=="STEEL" ) return IfcDoorStyleConstructionEnum::STEEL; + else if(s=="WOOD" ) return IfcDoorStyleConstructionEnum::WOOD; + else if(s=="ALUMINIUM_WOOD" ) return IfcDoorStyleConstructionEnum::ALUMINIUM_WOOD; + else if(s=="ALUMINIUM_PLASTIC") return IfcDoorStyleConstructionEnum::ALUMINIUM_PLASTIC; + else if(s=="PLASTIC" ) return IfcDoorStyleConstructionEnum::PLASTIC; + else if(s=="USERDEFINED" ) return IfcDoorStyleConstructionEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcDoorStyleConstructionEnum::NOTDEFINED; + else throw; +} +IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum IfcDoorStyleOperationEnum::FromString(const std::string& s){ + if (s=="SINGLE_SWING_LEFT" ) return IfcDoorStyleOperationEnum::SINGLE_SWING_LEFT; + else if(s=="SINGLE_SWING_RIGHT" ) return IfcDoorStyleOperationEnum::SINGLE_SWING_RIGHT; + else if(s=="DOUBLE_DOOR_SINGLE_SWING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SINGLE_SWING; + else if(s=="DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT; + else if(s=="DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT") return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT; + else if(s=="DOUBLE_SWING_LEFT" ) return IfcDoorStyleOperationEnum::DOUBLE_SWING_LEFT; + else if(s=="DOUBLE_SWING_RIGHT" ) return IfcDoorStyleOperationEnum::DOUBLE_SWING_RIGHT; + else if(s=="DOUBLE_DOOR_DOUBLE_SWING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_DOUBLE_SWING; + else if(s=="SLIDING_TO_LEFT" ) return IfcDoorStyleOperationEnum::SLIDING_TO_LEFT; + else if(s=="SLIDING_TO_RIGHT" ) return IfcDoorStyleOperationEnum::SLIDING_TO_RIGHT; + else if(s=="DOUBLE_DOOR_SLIDING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SLIDING; + else if(s=="FOLDING_TO_LEFT" ) return IfcDoorStyleOperationEnum::FOLDING_TO_LEFT; + else if(s=="FOLDING_TO_RIGHT" ) return IfcDoorStyleOperationEnum::FOLDING_TO_RIGHT; + else if(s=="DOUBLE_DOOR_FOLDING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_FOLDING; + else if(s=="REVOLVING" ) return IfcDoorStyleOperationEnum::REVOLVING; + else if(s=="ROLLINGUP" ) return IfcDoorStyleOperationEnum::ROLLINGUP; + else if(s=="USERDEFINED" ) return IfcDoorStyleOperationEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcDoorStyleOperationEnum::NOTDEFINED; + else throw; +} +IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum IfcDuctFittingTypeEnum::FromString(const std::string& s){ + if (s=="BEND" ) return IfcDuctFittingTypeEnum::BEND; + else if(s=="CONNECTOR" ) return IfcDuctFittingTypeEnum::CONNECTOR; + else if(s=="ENTRY" ) return IfcDuctFittingTypeEnum::ENTRY; + else if(s=="EXIT" ) return IfcDuctFittingTypeEnum::EXIT; + else if(s=="JUNCTION" ) return IfcDuctFittingTypeEnum::JUNCTION; + else if(s=="OBSTRUCTION") return IfcDuctFittingTypeEnum::OBSTRUCTION; + else if(s=="TRANSITION" ) return IfcDuctFittingTypeEnum::TRANSITION; + else if(s=="USERDEFINED") return IfcDuctFittingTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcDuctFittingTypeEnum::NOTDEFINED; + else throw; +} +IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum IfcDuctSegmentTypeEnum::FromString(const std::string& s){ + if (s=="RIGIDSEGMENT" ) return IfcDuctSegmentTypeEnum::RIGIDSEGMENT; + else if(s=="FLEXIBLESEGMENT") return IfcDuctSegmentTypeEnum::FLEXIBLESEGMENT; + else if(s=="USERDEFINED" ) return IfcDuctSegmentTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcDuctSegmentTypeEnum::NOTDEFINED; + else throw; +} +IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum IfcDuctSilencerTypeEnum::FromString(const std::string& s){ + if (s=="FLATOVAL" ) return IfcDuctSilencerTypeEnum::FLATOVAL; + else if(s=="RECTANGULAR") return IfcDuctSilencerTypeEnum::RECTANGULAR; + else if(s=="ROUND" ) return IfcDuctSilencerTypeEnum::ROUND; + else if(s=="USERDEFINED") return IfcDuctSilencerTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcDuctSilencerTypeEnum::NOTDEFINED; + else throw; +} +IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum IfcElectricApplianceTypeEnum::FromString(const std::string& s){ + if (s=="COMPUTER" ) return IfcElectricApplianceTypeEnum::COMPUTER; + else if(s=="DIRECTWATERHEATER" ) return IfcElectricApplianceTypeEnum::DIRECTWATERHEATER; + else if(s=="DISHWASHER" ) return IfcElectricApplianceTypeEnum::DISHWASHER; + else if(s=="ELECTRICCOOKER" ) return IfcElectricApplianceTypeEnum::ELECTRICCOOKER; + else if(s=="ELECTRICHEATER" ) return IfcElectricApplianceTypeEnum::ELECTRICHEATER; + else if(s=="FACSIMILE" ) return IfcElectricApplianceTypeEnum::FACSIMILE; + else if(s=="FREESTANDINGFAN" ) return IfcElectricApplianceTypeEnum::FREESTANDINGFAN; + else if(s=="FREEZER" ) return IfcElectricApplianceTypeEnum::FREEZER; + else if(s=="FRIDGE_FREEZER" ) return IfcElectricApplianceTypeEnum::FRIDGE_FREEZER; + else if(s=="HANDDRYER" ) return IfcElectricApplianceTypeEnum::HANDDRYER; + else if(s=="INDIRECTWATERHEATER") return IfcElectricApplianceTypeEnum::INDIRECTWATERHEATER; + else if(s=="MICROWAVE" ) return IfcElectricApplianceTypeEnum::MICROWAVE; + else if(s=="PHOTOCOPIER" ) return IfcElectricApplianceTypeEnum::PHOTOCOPIER; + else if(s=="PRINTER" ) return IfcElectricApplianceTypeEnum::PRINTER; + else if(s=="REFRIGERATOR" ) return IfcElectricApplianceTypeEnum::REFRIGERATOR; + else if(s=="RADIANTHEATER" ) return IfcElectricApplianceTypeEnum::RADIANTHEATER; + else if(s=="SCANNER" ) return IfcElectricApplianceTypeEnum::SCANNER; + else if(s=="TELEPHONE" ) return IfcElectricApplianceTypeEnum::TELEPHONE; + else if(s=="TUMBLEDRYER" ) return IfcElectricApplianceTypeEnum::TUMBLEDRYER; + else if(s=="TV" ) return IfcElectricApplianceTypeEnum::TV; + else if(s=="VENDINGMACHINE" ) return IfcElectricApplianceTypeEnum::VENDINGMACHINE; + else if(s=="WASHINGMACHINE" ) return IfcElectricApplianceTypeEnum::WASHINGMACHINE; + else if(s=="WATERHEATER" ) return IfcElectricApplianceTypeEnum::WATERHEATER; + else if(s=="WATERCOOLER" ) return IfcElectricApplianceTypeEnum::WATERCOOLER; + else if(s=="USERDEFINED" ) return IfcElectricApplianceTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcElectricApplianceTypeEnum::NOTDEFINED; + else throw; +} +IfcElectricCurrentEnum::IfcElectricCurrentEnum IfcElectricCurrentEnum::FromString(const std::string& s){ + if (s=="ALTERNATING") return IfcElectricCurrentEnum::ALTERNATING; + else if(s=="DIRECT" ) return IfcElectricCurrentEnum::DIRECT; + else if(s=="NOTDEFINED" ) return IfcElectricCurrentEnum::NOTDEFINED; + else throw; +} +IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum IfcElectricDistributionPointFunctionEnum::FromString(const std::string& s){ + if (s=="ALARMPANEL" ) return IfcElectricDistributionPointFunctionEnum::ALARMPANEL; + else if(s=="CONSUMERUNIT" ) return IfcElectricDistributionPointFunctionEnum::CONSUMERUNIT; + else if(s=="CONTROLPANEL" ) return IfcElectricDistributionPointFunctionEnum::CONTROLPANEL; + else if(s=="DISTRIBUTIONBOARD" ) return IfcElectricDistributionPointFunctionEnum::DISTRIBUTIONBOARD; + else if(s=="GASDETECTORPANEL" ) return IfcElectricDistributionPointFunctionEnum::GASDETECTORPANEL; + else if(s=="INDICATORPANEL" ) return IfcElectricDistributionPointFunctionEnum::INDICATORPANEL; + else if(s=="MIMICPANEL" ) return IfcElectricDistributionPointFunctionEnum::MIMICPANEL; + else if(s=="MOTORCONTROLCENTRE") return IfcElectricDistributionPointFunctionEnum::MOTORCONTROLCENTRE; + else if(s=="SWITCHBOARD" ) return IfcElectricDistributionPointFunctionEnum::SWITCHBOARD; + else if(s=="USERDEFINED" ) return IfcElectricDistributionPointFunctionEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcElectricDistributionPointFunctionEnum::NOTDEFINED; + else throw; +} +IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum IfcElectricFlowStorageDeviceTypeEnum::FromString(const std::string& s){ + if (s=="BATTERY" ) return IfcElectricFlowStorageDeviceTypeEnum::BATTERY; + else if(s=="CAPACITORBANK" ) return IfcElectricFlowStorageDeviceTypeEnum::CAPACITORBANK; + else if(s=="HARMONICFILTER") return IfcElectricFlowStorageDeviceTypeEnum::HARMONICFILTER; + else if(s=="INDUCTORBANK" ) return IfcElectricFlowStorageDeviceTypeEnum::INDUCTORBANK; + else if(s=="UPS" ) return IfcElectricFlowStorageDeviceTypeEnum::UPS; + else if(s=="USERDEFINED" ) return IfcElectricFlowStorageDeviceTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcElectricFlowStorageDeviceTypeEnum::NOTDEFINED; + else throw; +} +IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum IfcElectricGeneratorTypeEnum::FromString(const std::string& s){ + if (s=="USERDEFINED") return IfcElectricGeneratorTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcElectricGeneratorTypeEnum::NOTDEFINED; + else throw; +} +IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum IfcElectricHeaterTypeEnum::FromString(const std::string& s){ + if (s=="ELECTRICPOINTHEATER") return IfcElectricHeaterTypeEnum::ELECTRICPOINTHEATER; + else if(s=="ELECTRICCABLEHEATER") return IfcElectricHeaterTypeEnum::ELECTRICCABLEHEATER; + else if(s=="ELECTRICMATHEATER" ) return IfcElectricHeaterTypeEnum::ELECTRICMATHEATER; + else if(s=="USERDEFINED" ) return IfcElectricHeaterTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcElectricHeaterTypeEnum::NOTDEFINED; + else throw; +} +IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum IfcElectricMotorTypeEnum::FromString(const std::string& s){ + if (s=="DC" ) return IfcElectricMotorTypeEnum::DC; + else if(s=="INDUCTION" ) return IfcElectricMotorTypeEnum::INDUCTION; + else if(s=="POLYPHASE" ) return IfcElectricMotorTypeEnum::POLYPHASE; + else if(s=="RELUCTANCESYNCHRONOUS") return IfcElectricMotorTypeEnum::RELUCTANCESYNCHRONOUS; + else if(s=="SYNCHRONOUS" ) return IfcElectricMotorTypeEnum::SYNCHRONOUS; + else if(s=="USERDEFINED" ) return IfcElectricMotorTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcElectricMotorTypeEnum::NOTDEFINED; + else throw; +} +IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum IfcElectricTimeControlTypeEnum::FromString(const std::string& s){ + if (s=="TIMECLOCK" ) return IfcElectricTimeControlTypeEnum::TIMECLOCK; + else if(s=="TIMEDELAY" ) return IfcElectricTimeControlTypeEnum::TIMEDELAY; + else if(s=="RELAY" ) return IfcElectricTimeControlTypeEnum::RELAY; + else if(s=="USERDEFINED") return IfcElectricTimeControlTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcElectricTimeControlTypeEnum::NOTDEFINED; + else throw; +} +IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum IfcElementAssemblyTypeEnum::FromString(const std::string& s){ + if (s=="ACCESSORY_ASSEMBLY") return IfcElementAssemblyTypeEnum::ACCESSORY_ASSEMBLY; + else if(s=="ARCH" ) return IfcElementAssemblyTypeEnum::ARCH; + else if(s=="BEAM_GRID" ) return IfcElementAssemblyTypeEnum::BEAM_GRID; + else if(s=="BRACED_FRAME" ) return IfcElementAssemblyTypeEnum::BRACED_FRAME; + else if(s=="GIRDER" ) return IfcElementAssemblyTypeEnum::GIRDER; + else if(s=="REINFORCEMENT_UNIT") return IfcElementAssemblyTypeEnum::REINFORCEMENT_UNIT; + else if(s=="RIGID_FRAME" ) return IfcElementAssemblyTypeEnum::RIGID_FRAME; + else if(s=="SLAB_FIELD" ) return IfcElementAssemblyTypeEnum::SLAB_FIELD; + else if(s=="TRUSS" ) return IfcElementAssemblyTypeEnum::TRUSS; + else if(s=="USERDEFINED" ) return IfcElementAssemblyTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcElementAssemblyTypeEnum::NOTDEFINED; + else throw; +} +IfcElementCompositionEnum::IfcElementCompositionEnum IfcElementCompositionEnum::FromString(const std::string& s){ + if (s=="COMPLEX") return IfcElementCompositionEnum::COMPLEX; + else if(s=="ELEMENT") return IfcElementCompositionEnum::ELEMENT; + else if(s=="PARTIAL") return IfcElementCompositionEnum::PARTIAL; + else throw; +} +IfcEnergySequenceEnum::IfcEnergySequenceEnum IfcEnergySequenceEnum::FromString(const std::string& s){ + if (s=="PRIMARY" ) return IfcEnergySequenceEnum::PRIMARY; + else if(s=="SECONDARY" ) return IfcEnergySequenceEnum::SECONDARY; + else if(s=="TERTIARY" ) return IfcEnergySequenceEnum::TERTIARY; + else if(s=="AUXILIARY" ) return IfcEnergySequenceEnum::AUXILIARY; + else if(s=="USERDEFINED") return IfcEnergySequenceEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcEnergySequenceEnum::NOTDEFINED; + else throw; +} +IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum IfcEnvironmentalImpactCategoryEnum::FromString(const std::string& s){ + if (s=="COMBINEDVALUE" ) return IfcEnvironmentalImpactCategoryEnum::COMBINEDVALUE; + else if(s=="DISPOSAL" ) return IfcEnvironmentalImpactCategoryEnum::DISPOSAL; + else if(s=="EXTRACTION" ) return IfcEnvironmentalImpactCategoryEnum::EXTRACTION; + else if(s=="INSTALLATION" ) return IfcEnvironmentalImpactCategoryEnum::INSTALLATION; + else if(s=="MANUFACTURE" ) return IfcEnvironmentalImpactCategoryEnum::MANUFACTURE; + else if(s=="TRANSPORTATION") return IfcEnvironmentalImpactCategoryEnum::TRANSPORTATION; + else if(s=="USERDEFINED" ) return IfcEnvironmentalImpactCategoryEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcEnvironmentalImpactCategoryEnum::NOTDEFINED; + else throw; +} +IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum IfcEvaporativeCoolerTypeEnum::FromString(const std::string& s){ + if (s=="DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER; + else if(s=="DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER; + else if(s=="DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER; + else if(s=="DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER; + else if(s=="DIRECTEVAPORATIVEAIRWASHER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVEAIRWASHER; + else if(s=="INDIRECTEVAPORATIVEPACKAGEAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::INDIRECTEVAPORATIVEPACKAGEAIRCOOLER; + else if(s=="INDIRECTEVAPORATIVEWETCOIL" ) return IfcEvaporativeCoolerTypeEnum::INDIRECTEVAPORATIVEWETCOIL; + else if(s=="INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER") return IfcEvaporativeCoolerTypeEnum::INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER; + else if(s=="INDIRECTDIRECTCOMBINATION" ) return IfcEvaporativeCoolerTypeEnum::INDIRECTDIRECTCOMBINATION; + else if(s=="USERDEFINED" ) return IfcEvaporativeCoolerTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcEvaporativeCoolerTypeEnum::NOTDEFINED; + else throw; +} +IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum IfcEvaporatorTypeEnum::FromString(const std::string& s){ + if (s=="DIRECTEXPANSIONSHELLANDTUBE") return IfcEvaporatorTypeEnum::DIRECTEXPANSIONSHELLANDTUBE; + else if(s=="DIRECTEXPANSIONTUBEINTUBE" ) return IfcEvaporatorTypeEnum::DIRECTEXPANSIONTUBEINTUBE; + else if(s=="DIRECTEXPANSIONBRAZEDPLATE" ) return IfcEvaporatorTypeEnum::DIRECTEXPANSIONBRAZEDPLATE; + else if(s=="FLOODEDSHELLANDTUBE" ) return IfcEvaporatorTypeEnum::FLOODEDSHELLANDTUBE; + else if(s=="SHELLANDCOIL" ) return IfcEvaporatorTypeEnum::SHELLANDCOIL; + else if(s=="USERDEFINED" ) return IfcEvaporatorTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcEvaporatorTypeEnum::NOTDEFINED; + else throw; +} +IfcFanTypeEnum::IfcFanTypeEnum IfcFanTypeEnum::FromString(const std::string& s){ + if (s=="CENTRIFUGALFORWARDCURVED" ) return IfcFanTypeEnum::CENTRIFUGALFORWARDCURVED; + else if(s=="CENTRIFUGALRADIAL" ) return IfcFanTypeEnum::CENTRIFUGALRADIAL; + else if(s=="CENTRIFUGALBACKWARDINCLINEDCURVED") return IfcFanTypeEnum::CENTRIFUGALBACKWARDINCLINEDCURVED; + else if(s=="CENTRIFUGALAIRFOIL" ) return IfcFanTypeEnum::CENTRIFUGALAIRFOIL; + else if(s=="TUBEAXIAL" ) return IfcFanTypeEnum::TUBEAXIAL; + else if(s=="VANEAXIAL" ) return IfcFanTypeEnum::VANEAXIAL; + else if(s=="PROPELLORAXIAL" ) return IfcFanTypeEnum::PROPELLORAXIAL; + else if(s=="USERDEFINED" ) return IfcFanTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcFanTypeEnum::NOTDEFINED; + else throw; +} +IfcFilterTypeEnum::IfcFilterTypeEnum IfcFilterTypeEnum::FromString(const std::string& s){ + if (s=="AIRPARTICLEFILTER") return IfcFilterTypeEnum::AIRPARTICLEFILTER; + else if(s=="ODORFILTER" ) return IfcFilterTypeEnum::ODORFILTER; + else if(s=="OILFILTER" ) return IfcFilterTypeEnum::OILFILTER; + else if(s=="STRAINER" ) return IfcFilterTypeEnum::STRAINER; + else if(s=="WATERFILTER" ) return IfcFilterTypeEnum::WATERFILTER; + else if(s=="USERDEFINED" ) return IfcFilterTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcFilterTypeEnum::NOTDEFINED; + else throw; +} +IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum IfcFireSuppressionTerminalTypeEnum::FromString(const std::string& s){ + if (s=="BREECHINGINLET" ) return IfcFireSuppressionTerminalTypeEnum::BREECHINGINLET; + else if(s=="FIREHYDRANT" ) return IfcFireSuppressionTerminalTypeEnum::FIREHYDRANT; + else if(s=="HOSEREEL" ) return IfcFireSuppressionTerminalTypeEnum::HOSEREEL; + else if(s=="SPRINKLER" ) return IfcFireSuppressionTerminalTypeEnum::SPRINKLER; + else if(s=="SPRINKLERDEFLECTOR") return IfcFireSuppressionTerminalTypeEnum::SPRINKLERDEFLECTOR; + else if(s=="USERDEFINED" ) return IfcFireSuppressionTerminalTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcFireSuppressionTerminalTypeEnum::NOTDEFINED; + else throw; +} +IfcFlowDirectionEnum::IfcFlowDirectionEnum IfcFlowDirectionEnum::FromString(const std::string& s){ + if (s=="SOURCE" ) return IfcFlowDirectionEnum::SOURCE; + else if(s=="SINK" ) return IfcFlowDirectionEnum::SINK; + else if(s=="SOURCEANDSINK") return IfcFlowDirectionEnum::SOURCEANDSINK; + else if(s=="NOTDEFINED" ) return IfcFlowDirectionEnum::NOTDEFINED; + else throw; +} +IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum IfcFlowInstrumentTypeEnum::FromString(const std::string& s){ + if (s=="PRESSUREGAUGE" ) return IfcFlowInstrumentTypeEnum::PRESSUREGAUGE; + else if(s=="THERMOMETER" ) return IfcFlowInstrumentTypeEnum::THERMOMETER; + else if(s=="AMMETER" ) return IfcFlowInstrumentTypeEnum::AMMETER; + else if(s=="FREQUENCYMETER" ) return IfcFlowInstrumentTypeEnum::FREQUENCYMETER; + else if(s=="POWERFACTORMETER") return IfcFlowInstrumentTypeEnum::POWERFACTORMETER; + else if(s=="PHASEANGLEMETER" ) return IfcFlowInstrumentTypeEnum::PHASEANGLEMETER; + else if(s=="VOLTMETER_PEAK" ) return IfcFlowInstrumentTypeEnum::VOLTMETER_PEAK; + else if(s=="VOLTMETER_RMS" ) return IfcFlowInstrumentTypeEnum::VOLTMETER_RMS; + else if(s=="USERDEFINED" ) return IfcFlowInstrumentTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcFlowInstrumentTypeEnum::NOTDEFINED; + else throw; +} +IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum IfcFlowMeterTypeEnum::FromString(const std::string& s){ + if (s=="ELECTRICMETER") return IfcFlowMeterTypeEnum::ELECTRICMETER; + else if(s=="ENERGYMETER" ) return IfcFlowMeterTypeEnum::ENERGYMETER; + else if(s=="FLOWMETER" ) return IfcFlowMeterTypeEnum::FLOWMETER; + else if(s=="GASMETER" ) return IfcFlowMeterTypeEnum::GASMETER; + else if(s=="OILMETER" ) return IfcFlowMeterTypeEnum::OILMETER; + else if(s=="WATERMETER" ) return IfcFlowMeterTypeEnum::WATERMETER; + else if(s=="USERDEFINED" ) return IfcFlowMeterTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcFlowMeterTypeEnum::NOTDEFINED; + else throw; +} +IfcFootingTypeEnum::IfcFootingTypeEnum IfcFootingTypeEnum::FromString(const std::string& s){ + if (s=="FOOTING_BEAM" ) return IfcFootingTypeEnum::FOOTING_BEAM; + else if(s=="PAD_FOOTING" ) return IfcFootingTypeEnum::PAD_FOOTING; + else if(s=="PILE_CAP" ) return IfcFootingTypeEnum::PILE_CAP; + else if(s=="STRIP_FOOTING") return IfcFootingTypeEnum::STRIP_FOOTING; + else if(s=="USERDEFINED" ) return IfcFootingTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcFootingTypeEnum::NOTDEFINED; + else throw; +} +IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum IfcGasTerminalTypeEnum::FromString(const std::string& s){ + if (s=="GASAPPLIANCE") return IfcGasTerminalTypeEnum::GASAPPLIANCE; + else if(s=="GASBOOSTER" ) return IfcGasTerminalTypeEnum::GASBOOSTER; + else if(s=="GASBURNER" ) return IfcGasTerminalTypeEnum::GASBURNER; + else if(s=="USERDEFINED" ) return IfcGasTerminalTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcGasTerminalTypeEnum::NOTDEFINED; + else throw; +} +IfcGeometricProjectionEnum::IfcGeometricProjectionEnum IfcGeometricProjectionEnum::FromString(const std::string& s){ + if (s=="GRAPH_VIEW" ) return IfcGeometricProjectionEnum::GRAPH_VIEW; + else if(s=="SKETCH_VIEW" ) return IfcGeometricProjectionEnum::SKETCH_VIEW; + else if(s=="MODEL_VIEW" ) return IfcGeometricProjectionEnum::MODEL_VIEW; + else if(s=="PLAN_VIEW" ) return IfcGeometricProjectionEnum::PLAN_VIEW; + else if(s=="REFLECTED_PLAN_VIEW") return IfcGeometricProjectionEnum::REFLECTED_PLAN_VIEW; + else if(s=="SECTION_VIEW" ) return IfcGeometricProjectionEnum::SECTION_VIEW; + else if(s=="ELEVATION_VIEW" ) return IfcGeometricProjectionEnum::ELEVATION_VIEW; + else if(s=="USERDEFINED" ) return IfcGeometricProjectionEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcGeometricProjectionEnum::NOTDEFINED; + else throw; +} +IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum IfcGlobalOrLocalEnum::FromString(const std::string& s){ + if (s=="GLOBAL_COORDS") return IfcGlobalOrLocalEnum::GLOBAL_COORDS; + else if(s=="LOCAL_COORDS" ) return IfcGlobalOrLocalEnum::LOCAL_COORDS; + else throw; +} +IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum IfcHeatExchangerTypeEnum::FromString(const std::string& s){ + if (s=="PLATE" ) return IfcHeatExchangerTypeEnum::PLATE; + else if(s=="SHELLANDTUBE") return IfcHeatExchangerTypeEnum::SHELLANDTUBE; + else if(s=="USERDEFINED" ) return IfcHeatExchangerTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcHeatExchangerTypeEnum::NOTDEFINED; + else throw; +} +IfcHumidifierTypeEnum::IfcHumidifierTypeEnum IfcHumidifierTypeEnum::FromString(const std::string& s){ + if (s=="STEAMINJECTION" ) return IfcHumidifierTypeEnum::STEAMINJECTION; + else if(s=="ADIABATICAIRWASHER" ) return IfcHumidifierTypeEnum::ADIABATICAIRWASHER; + else if(s=="ADIABATICPAN" ) return IfcHumidifierTypeEnum::ADIABATICPAN; + else if(s=="ADIABATICWETTEDELEMENT" ) return IfcHumidifierTypeEnum::ADIABATICWETTEDELEMENT; + else if(s=="ADIABATICATOMIZING" ) return IfcHumidifierTypeEnum::ADIABATICATOMIZING; + else if(s=="ADIABATICULTRASONIC" ) return IfcHumidifierTypeEnum::ADIABATICULTRASONIC; + else if(s=="ADIABATICRIGIDMEDIA" ) return IfcHumidifierTypeEnum::ADIABATICRIGIDMEDIA; + else if(s=="ADIABATICCOMPRESSEDAIRNOZZLE") return IfcHumidifierTypeEnum::ADIABATICCOMPRESSEDAIRNOZZLE; + else if(s=="ASSISTEDELECTRIC" ) return IfcHumidifierTypeEnum::ASSISTEDELECTRIC; + else if(s=="ASSISTEDNATURALGAS" ) return IfcHumidifierTypeEnum::ASSISTEDNATURALGAS; + else if(s=="ASSISTEDPROPANE" ) return IfcHumidifierTypeEnum::ASSISTEDPROPANE; + else if(s=="ASSISTEDBUTANE" ) return IfcHumidifierTypeEnum::ASSISTEDBUTANE; + else if(s=="ASSISTEDSTEAM" ) return IfcHumidifierTypeEnum::ASSISTEDSTEAM; + else if(s=="USERDEFINED" ) return IfcHumidifierTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcHumidifierTypeEnum::NOTDEFINED; + else throw; +} +IfcInternalOrExternalEnum::IfcInternalOrExternalEnum IfcInternalOrExternalEnum::FromString(const std::string& s){ + if (s=="INTERNAL" ) return IfcInternalOrExternalEnum::INTERNAL; + else if(s=="EXTERNAL" ) return IfcInternalOrExternalEnum::EXTERNAL; + else if(s=="NOTDEFINED") return IfcInternalOrExternalEnum::NOTDEFINED; + else throw; +} +IfcInventoryTypeEnum::IfcInventoryTypeEnum IfcInventoryTypeEnum::FromString(const std::string& s){ + if (s=="ASSETINVENTORY" ) return IfcInventoryTypeEnum::ASSETINVENTORY; + else if(s=="SPACEINVENTORY" ) return IfcInventoryTypeEnum::SPACEINVENTORY; + else if(s=="FURNITUREINVENTORY") return IfcInventoryTypeEnum::FURNITUREINVENTORY; + else if(s=="USERDEFINED" ) return IfcInventoryTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcInventoryTypeEnum::NOTDEFINED; + else throw; +} +IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum IfcJunctionBoxTypeEnum::FromString(const std::string& s){ + if (s=="USERDEFINED") return IfcJunctionBoxTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcJunctionBoxTypeEnum::NOTDEFINED; + else throw; +} +IfcLampTypeEnum::IfcLampTypeEnum IfcLampTypeEnum::FromString(const std::string& s){ + if (s=="COMPACTFLUORESCENT" ) return IfcLampTypeEnum::COMPACTFLUORESCENT; + else if(s=="FLUORESCENT" ) return IfcLampTypeEnum::FLUORESCENT; + else if(s=="HIGHPRESSUREMERCURY") return IfcLampTypeEnum::HIGHPRESSUREMERCURY; + else if(s=="HIGHPRESSURESODIUM" ) return IfcLampTypeEnum::HIGHPRESSURESODIUM; + else if(s=="METALHALIDE" ) return IfcLampTypeEnum::METALHALIDE; + else if(s=="TUNGSTENFILAMENT" ) return IfcLampTypeEnum::TUNGSTENFILAMENT; + else if(s=="USERDEFINED" ) return IfcLampTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcLampTypeEnum::NOTDEFINED; + else throw; +} +IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum IfcLayerSetDirectionEnum::FromString(const std::string& s){ + if (s=="AXIS1") return IfcLayerSetDirectionEnum::AXIS1; + else if(s=="AXIS2") return IfcLayerSetDirectionEnum::AXIS2; + else if(s=="AXIS3") return IfcLayerSetDirectionEnum::AXIS3; + else throw; +} +IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum IfcLightDistributionCurveEnum::FromString(const std::string& s){ + if (s=="TYPE_A" ) return IfcLightDistributionCurveEnum::TYPE_A; + else if(s=="TYPE_B" ) return IfcLightDistributionCurveEnum::TYPE_B; + else if(s=="TYPE_C" ) return IfcLightDistributionCurveEnum::TYPE_C; + else if(s=="NOTDEFINED") return IfcLightDistributionCurveEnum::NOTDEFINED; + else throw; +} +IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum IfcLightEmissionSourceEnum::FromString(const std::string& s){ + if (s=="COMPACTFLUORESCENT" ) return IfcLightEmissionSourceEnum::COMPACTFLUORESCENT; + else if(s=="FLUORESCENT" ) return IfcLightEmissionSourceEnum::FLUORESCENT; + else if(s=="HIGHPRESSUREMERCURY") return IfcLightEmissionSourceEnum::HIGHPRESSUREMERCURY; + else if(s=="HIGHPRESSURESODIUM" ) return IfcLightEmissionSourceEnum::HIGHPRESSURESODIUM; + else if(s=="LIGHTEMITTINGDIODE" ) return IfcLightEmissionSourceEnum::LIGHTEMITTINGDIODE; + else if(s=="LOWPRESSURESODIUM" ) return IfcLightEmissionSourceEnum::LOWPRESSURESODIUM; + else if(s=="LOWVOLTAGEHALOGEN" ) return IfcLightEmissionSourceEnum::LOWVOLTAGEHALOGEN; + else if(s=="MAINVOLTAGEHALOGEN" ) return IfcLightEmissionSourceEnum::MAINVOLTAGEHALOGEN; + else if(s=="METALHALIDE" ) return IfcLightEmissionSourceEnum::METALHALIDE; + else if(s=="TUNGSTENFILAMENT" ) return IfcLightEmissionSourceEnum::TUNGSTENFILAMENT; + else if(s=="NOTDEFINED" ) return IfcLightEmissionSourceEnum::NOTDEFINED; + else throw; +} +IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum IfcLightFixtureTypeEnum::FromString(const std::string& s){ + if (s=="POINTSOURCE" ) return IfcLightFixtureTypeEnum::POINTSOURCE; + else if(s=="DIRECTIONSOURCE") return IfcLightFixtureTypeEnum::DIRECTIONSOURCE; + else if(s=="USERDEFINED" ) return IfcLightFixtureTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcLightFixtureTypeEnum::NOTDEFINED; + else throw; +} +IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum IfcLoadGroupTypeEnum::FromString(const std::string& s){ + if (s=="LOAD_GROUP" ) return IfcLoadGroupTypeEnum::LOAD_GROUP; + else if(s=="LOAD_CASE" ) return IfcLoadGroupTypeEnum::LOAD_CASE; + else if(s=="LOAD_COMBINATION_GROUP") return IfcLoadGroupTypeEnum::LOAD_COMBINATION_GROUP; + else if(s=="LOAD_COMBINATION" ) return IfcLoadGroupTypeEnum::LOAD_COMBINATION; + else if(s=="USERDEFINED" ) return IfcLoadGroupTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcLoadGroupTypeEnum::NOTDEFINED; + else throw; +} +IfcLogicalOperatorEnum::IfcLogicalOperatorEnum IfcLogicalOperatorEnum::FromString(const std::string& s){ + if (s=="LOGICALAND") return IfcLogicalOperatorEnum::LOGICALAND; + else if(s=="LOGICALOR" ) return IfcLogicalOperatorEnum::LOGICALOR; + else throw; +} +IfcMemberTypeEnum::IfcMemberTypeEnum IfcMemberTypeEnum::FromString(const std::string& s){ + if (s=="BRACE" ) return IfcMemberTypeEnum::BRACE; + else if(s=="CHORD" ) return IfcMemberTypeEnum::CHORD; + else if(s=="COLLAR" ) return IfcMemberTypeEnum::COLLAR; + else if(s=="MEMBER" ) return IfcMemberTypeEnum::MEMBER; + else if(s=="MULLION" ) return IfcMemberTypeEnum::MULLION; + else if(s=="PLATE" ) return IfcMemberTypeEnum::PLATE; + else if(s=="POST" ) return IfcMemberTypeEnum::POST; + else if(s=="PURLIN" ) return IfcMemberTypeEnum::PURLIN; + else if(s=="RAFTER" ) return IfcMemberTypeEnum::RAFTER; + else if(s=="STRINGER" ) return IfcMemberTypeEnum::STRINGER; + else if(s=="STRUT" ) return IfcMemberTypeEnum::STRUT; + else if(s=="STUD" ) return IfcMemberTypeEnum::STUD; + else if(s=="USERDEFINED") return IfcMemberTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcMemberTypeEnum::NOTDEFINED; + else throw; +} +IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum IfcMotorConnectionTypeEnum::FromString(const std::string& s){ + if (s=="BELTDRIVE" ) return IfcMotorConnectionTypeEnum::BELTDRIVE; + else if(s=="COUPLING" ) return IfcMotorConnectionTypeEnum::COUPLING; + else if(s=="DIRECTDRIVE") return IfcMotorConnectionTypeEnum::DIRECTDRIVE; + else if(s=="USERDEFINED") return IfcMotorConnectionTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcMotorConnectionTypeEnum::NOTDEFINED; + else throw; +} +IfcNullStyle::IfcNullStyle IfcNullStyle::FromString(const std::string& s){ + if (s=="NULL") return IfcNullStyle::IFC_NULL; + else throw; +} +IfcObjectTypeEnum::IfcObjectTypeEnum IfcObjectTypeEnum::FromString(const std::string& s){ + if (s=="PRODUCT" ) return IfcObjectTypeEnum::PRODUCT; + else if(s=="PROCESS" ) return IfcObjectTypeEnum::PROCESS; + else if(s=="CONTROL" ) return IfcObjectTypeEnum::CONTROL; + else if(s=="RESOURCE" ) return IfcObjectTypeEnum::RESOURCE; + else if(s=="ACTOR" ) return IfcObjectTypeEnum::ACTOR; + else if(s=="GROUP" ) return IfcObjectTypeEnum::GROUP; + else if(s=="PROJECT" ) return IfcObjectTypeEnum::PROJECT; + else if(s=="NOTDEFINED") return IfcObjectTypeEnum::NOTDEFINED; + else throw; +} +IfcObjectiveEnum::IfcObjectiveEnum IfcObjectiveEnum::FromString(const std::string& s){ + if (s=="CODECOMPLIANCE" ) return IfcObjectiveEnum::CODECOMPLIANCE; + else if(s=="DESIGNINTENT" ) return IfcObjectiveEnum::DESIGNINTENT; + else if(s=="HEALTHANDSAFETY" ) return IfcObjectiveEnum::HEALTHANDSAFETY; + else if(s=="REQUIREMENT" ) return IfcObjectiveEnum::REQUIREMENT; + else if(s=="SPECIFICATION" ) return IfcObjectiveEnum::SPECIFICATION; + else if(s=="TRIGGERCONDITION") return IfcObjectiveEnum::TRIGGERCONDITION; + else if(s=="USERDEFINED" ) return IfcObjectiveEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcObjectiveEnum::NOTDEFINED; + else throw; +} +IfcOccupantTypeEnum::IfcOccupantTypeEnum IfcOccupantTypeEnum::FromString(const std::string& s){ + if (s=="ASSIGNEE" ) return IfcOccupantTypeEnum::ASSIGNEE; + else if(s=="ASSIGNOR" ) return IfcOccupantTypeEnum::ASSIGNOR; + else if(s=="LESSEE" ) return IfcOccupantTypeEnum::LESSEE; + else if(s=="LESSOR" ) return IfcOccupantTypeEnum::LESSOR; + else if(s=="LETTINGAGENT") return IfcOccupantTypeEnum::LETTINGAGENT; + else if(s=="OWNER" ) return IfcOccupantTypeEnum::OWNER; + else if(s=="TENANT" ) return IfcOccupantTypeEnum::TENANT; + else if(s=="USERDEFINED" ) return IfcOccupantTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcOccupantTypeEnum::NOTDEFINED; + else throw; +} +IfcOutletTypeEnum::IfcOutletTypeEnum IfcOutletTypeEnum::FromString(const std::string& s){ + if (s=="AUDIOVISUALOUTLET" ) return IfcOutletTypeEnum::AUDIOVISUALOUTLET; + else if(s=="COMMUNICATIONSOUTLET") return IfcOutletTypeEnum::COMMUNICATIONSOUTLET; + else if(s=="POWEROUTLET" ) return IfcOutletTypeEnum::POWEROUTLET; + else if(s=="USERDEFINED" ) return IfcOutletTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcOutletTypeEnum::NOTDEFINED; + else throw; +} +IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum IfcPermeableCoveringOperationEnum::FromString(const std::string& s){ + if (s=="GRILL" ) return IfcPermeableCoveringOperationEnum::GRILL; + else if(s=="LOUVER" ) return IfcPermeableCoveringOperationEnum::LOUVER; + else if(s=="SCREEN" ) return IfcPermeableCoveringOperationEnum::SCREEN; + else if(s=="USERDEFINED") return IfcPermeableCoveringOperationEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcPermeableCoveringOperationEnum::NOTDEFINED; + else throw; +} +IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum IfcPhysicalOrVirtualEnum::FromString(const std::string& s){ + if (s=="PHYSICAL" ) return IfcPhysicalOrVirtualEnum::PHYSICAL; + else if(s=="VIRTUAL" ) return IfcPhysicalOrVirtualEnum::VIRTUAL; + else if(s=="NOTDEFINED") return IfcPhysicalOrVirtualEnum::NOTDEFINED; + else throw; +} +IfcPileConstructionEnum::IfcPileConstructionEnum IfcPileConstructionEnum::FromString(const std::string& s){ + if (s=="CAST_IN_PLACE" ) return IfcPileConstructionEnum::CAST_IN_PLACE; + else if(s=="COMPOSITE" ) return IfcPileConstructionEnum::COMPOSITE; + else if(s=="PRECAST_CONCRETE") return IfcPileConstructionEnum::PRECAST_CONCRETE; + else if(s=="PREFAB_STEEL" ) return IfcPileConstructionEnum::PREFAB_STEEL; + else if(s=="USERDEFINED" ) return IfcPileConstructionEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcPileConstructionEnum::NOTDEFINED; + else throw; +} +IfcPileTypeEnum::IfcPileTypeEnum IfcPileTypeEnum::FromString(const std::string& s){ + if (s=="COHESION" ) return IfcPileTypeEnum::COHESION; + else if(s=="FRICTION" ) return IfcPileTypeEnum::FRICTION; + else if(s=="SUPPORT" ) return IfcPileTypeEnum::SUPPORT; + else if(s=="USERDEFINED") return IfcPileTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcPileTypeEnum::NOTDEFINED; + else throw; +} +IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum IfcPipeFittingTypeEnum::FromString(const std::string& s){ + if (s=="BEND" ) return IfcPipeFittingTypeEnum::BEND; + else if(s=="CONNECTOR" ) return IfcPipeFittingTypeEnum::CONNECTOR; + else if(s=="ENTRY" ) return IfcPipeFittingTypeEnum::ENTRY; + else if(s=="EXIT" ) return IfcPipeFittingTypeEnum::EXIT; + else if(s=="JUNCTION" ) return IfcPipeFittingTypeEnum::JUNCTION; + else if(s=="OBSTRUCTION") return IfcPipeFittingTypeEnum::OBSTRUCTION; + else if(s=="TRANSITION" ) return IfcPipeFittingTypeEnum::TRANSITION; + else if(s=="USERDEFINED") return IfcPipeFittingTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcPipeFittingTypeEnum::NOTDEFINED; + else throw; +} +IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum IfcPipeSegmentTypeEnum::FromString(const std::string& s){ + if (s=="FLEXIBLESEGMENT") return IfcPipeSegmentTypeEnum::FLEXIBLESEGMENT; + else if(s=="RIGIDSEGMENT" ) return IfcPipeSegmentTypeEnum::RIGIDSEGMENT; + else if(s=="GUTTER" ) return IfcPipeSegmentTypeEnum::GUTTER; + else if(s=="SPOOL" ) return IfcPipeSegmentTypeEnum::SPOOL; + else if(s=="USERDEFINED" ) return IfcPipeSegmentTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcPipeSegmentTypeEnum::NOTDEFINED; + else throw; +} +IfcPlateTypeEnum::IfcPlateTypeEnum IfcPlateTypeEnum::FromString(const std::string& s){ + if (s=="CURTAIN_PANEL") return IfcPlateTypeEnum::CURTAIN_PANEL; + else if(s=="SHEET" ) return IfcPlateTypeEnum::SHEET; + else if(s=="USERDEFINED" ) return IfcPlateTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcPlateTypeEnum::NOTDEFINED; + else throw; +} +IfcProcedureTypeEnum::IfcProcedureTypeEnum IfcProcedureTypeEnum::FromString(const std::string& s){ + if (s=="ADVICE_CAUTION") return IfcProcedureTypeEnum::ADVICE_CAUTION; + else if(s=="ADVICE_NOTE" ) return IfcProcedureTypeEnum::ADVICE_NOTE; + else if(s=="ADVICE_WARNING") return IfcProcedureTypeEnum::ADVICE_WARNING; + else if(s=="CALIBRATION" ) return IfcProcedureTypeEnum::CALIBRATION; + else if(s=="DIAGNOSTIC" ) return IfcProcedureTypeEnum::DIAGNOSTIC; + else if(s=="SHUTDOWN" ) return IfcProcedureTypeEnum::SHUTDOWN; + else if(s=="STARTUP" ) return IfcProcedureTypeEnum::STARTUP; + else if(s=="USERDEFINED" ) return IfcProcedureTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcProcedureTypeEnum::NOTDEFINED; + else throw; +} +IfcProfileTypeEnum::IfcProfileTypeEnum IfcProfileTypeEnum::FromString(const std::string& s){ + if (s=="CURVE") return IfcProfileTypeEnum::CURVE; + else if(s=="AREA" ) return IfcProfileTypeEnum::AREA; + else throw; +} +IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum IfcProjectOrderRecordTypeEnum::FromString(const std::string& s){ + if (s=="CHANGE" ) return IfcProjectOrderRecordTypeEnum::CHANGE; + else if(s=="MAINTENANCE") return IfcProjectOrderRecordTypeEnum::MAINTENANCE; + else if(s=="MOVE" ) return IfcProjectOrderRecordTypeEnum::MOVE; + else if(s=="PURCHASE" ) return IfcProjectOrderRecordTypeEnum::PURCHASE; + else if(s=="WORK" ) return IfcProjectOrderRecordTypeEnum::WORK; + else if(s=="USERDEFINED") return IfcProjectOrderRecordTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcProjectOrderRecordTypeEnum::NOTDEFINED; + else throw; +} +IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum IfcProjectOrderTypeEnum::FromString(const std::string& s){ + if (s=="CHANGEORDER" ) return IfcProjectOrderTypeEnum::CHANGEORDER; + else if(s=="MAINTENANCEWORKORDER") return IfcProjectOrderTypeEnum::MAINTENANCEWORKORDER; + else if(s=="MOVEORDER" ) return IfcProjectOrderTypeEnum::MOVEORDER; + else if(s=="PURCHASEORDER" ) return IfcProjectOrderTypeEnum::PURCHASEORDER; + else if(s=="WORKORDER" ) return IfcProjectOrderTypeEnum::WORKORDER; + else if(s=="USERDEFINED" ) return IfcProjectOrderTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcProjectOrderTypeEnum::NOTDEFINED; + else throw; +} +IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcProjectedOrTrueLengthEnum::FromString(const std::string& s){ + if (s=="PROJECTED_LENGTH") return IfcProjectedOrTrueLengthEnum::PROJECTED_LENGTH; + else if(s=="TRUE_LENGTH" ) return IfcProjectedOrTrueLengthEnum::TRUE_LENGTH; + else throw; +} +IfcPropertySourceEnum::IfcPropertySourceEnum IfcPropertySourceEnum::FromString(const std::string& s){ + if (s=="DESIGN" ) return IfcPropertySourceEnum::DESIGN; + else if(s=="DESIGNMAXIMUM") return IfcPropertySourceEnum::DESIGNMAXIMUM; + else if(s=="DESIGNMINIMUM") return IfcPropertySourceEnum::DESIGNMINIMUM; + else if(s=="SIMULATED" ) return IfcPropertySourceEnum::SIMULATED; + else if(s=="ASBUILT" ) return IfcPropertySourceEnum::ASBUILT; + else if(s=="COMMISSIONING") return IfcPropertySourceEnum::COMMISSIONING; + else if(s=="MEASURED" ) return IfcPropertySourceEnum::MEASURED; + else if(s=="USERDEFINED" ) return IfcPropertySourceEnum::USERDEFINED; + else if(s=="NOTKNOWN" ) return IfcPropertySourceEnum::NOTKNOWN; + else throw; +} +IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum IfcProtectiveDeviceTypeEnum::FromString(const std::string& s){ + if (s=="FUSEDISCONNECTOR" ) return IfcProtectiveDeviceTypeEnum::FUSEDISCONNECTOR; + else if(s=="CIRCUITBREAKER" ) return IfcProtectiveDeviceTypeEnum::CIRCUITBREAKER; + else if(s=="EARTHFAILUREDEVICE" ) return IfcProtectiveDeviceTypeEnum::EARTHFAILUREDEVICE; + else if(s=="RESIDUALCURRENTCIRCUITBREAKER") return IfcProtectiveDeviceTypeEnum::RESIDUALCURRENTCIRCUITBREAKER; + else if(s=="RESIDUALCURRENTSWITCH" ) return IfcProtectiveDeviceTypeEnum::RESIDUALCURRENTSWITCH; + else if(s=="VARISTOR" ) return IfcProtectiveDeviceTypeEnum::VARISTOR; + else if(s=="USERDEFINED" ) return IfcProtectiveDeviceTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcProtectiveDeviceTypeEnum::NOTDEFINED; + else throw; +} +IfcPumpTypeEnum::IfcPumpTypeEnum IfcPumpTypeEnum::FromString(const std::string& s){ + if (s=="CIRCULATOR" ) return IfcPumpTypeEnum::CIRCULATOR; + else if(s=="ENDSUCTION" ) return IfcPumpTypeEnum::ENDSUCTION; + else if(s=="SPLITCASE" ) return IfcPumpTypeEnum::SPLITCASE; + else if(s=="VERTICALINLINE" ) return IfcPumpTypeEnum::VERTICALINLINE; + else if(s=="VERTICALTURBINE") return IfcPumpTypeEnum::VERTICALTURBINE; + else if(s=="USERDEFINED" ) return IfcPumpTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcPumpTypeEnum::NOTDEFINED; + else throw; +} +IfcRailingTypeEnum::IfcRailingTypeEnum IfcRailingTypeEnum::FromString(const std::string& s){ + if (s=="HANDRAIL" ) return IfcRailingTypeEnum::HANDRAIL; + else if(s=="GUARDRAIL" ) return IfcRailingTypeEnum::GUARDRAIL; + else if(s=="BALUSTRADE" ) return IfcRailingTypeEnum::BALUSTRADE; + else if(s=="USERDEFINED") return IfcRailingTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcRailingTypeEnum::NOTDEFINED; + else throw; +} +IfcRampFlightTypeEnum::IfcRampFlightTypeEnum IfcRampFlightTypeEnum::FromString(const std::string& s){ + if (s=="STRAIGHT" ) return IfcRampFlightTypeEnum::STRAIGHT; + else if(s=="SPIRAL" ) return IfcRampFlightTypeEnum::SPIRAL; + else if(s=="USERDEFINED") return IfcRampFlightTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcRampFlightTypeEnum::NOTDEFINED; + else throw; +} +IfcRampTypeEnum::IfcRampTypeEnum IfcRampTypeEnum::FromString(const std::string& s){ + if (s=="STRAIGHT_RUN_RAMP" ) return IfcRampTypeEnum::STRAIGHT_RUN_RAMP; + else if(s=="TWO_STRAIGHT_RUN_RAMP") return IfcRampTypeEnum::TWO_STRAIGHT_RUN_RAMP; + else if(s=="QUARTER_TURN_RAMP" ) return IfcRampTypeEnum::QUARTER_TURN_RAMP; + else if(s=="TWO_QUARTER_TURN_RAMP") return IfcRampTypeEnum::TWO_QUARTER_TURN_RAMP; + else if(s=="HALF_TURN_RAMP" ) return IfcRampTypeEnum::HALF_TURN_RAMP; + else if(s=="SPIRAL_RAMP" ) return IfcRampTypeEnum::SPIRAL_RAMP; + else if(s=="USERDEFINED" ) return IfcRampTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcRampTypeEnum::NOTDEFINED; + else throw; +} +IfcReflectanceMethodEnum::IfcReflectanceMethodEnum IfcReflectanceMethodEnum::FromString(const std::string& s){ + if (s=="BLINN" ) return IfcReflectanceMethodEnum::BLINN; + else if(s=="FLAT" ) return IfcReflectanceMethodEnum::FLAT; + else if(s=="GLASS" ) return IfcReflectanceMethodEnum::GLASS; + else if(s=="MATT" ) return IfcReflectanceMethodEnum::MATT; + else if(s=="METAL" ) return IfcReflectanceMethodEnum::METAL; + else if(s=="MIRROR" ) return IfcReflectanceMethodEnum::MIRROR; + else if(s=="PHONG" ) return IfcReflectanceMethodEnum::PHONG; + else if(s=="PLASTIC" ) return IfcReflectanceMethodEnum::PLASTIC; + else if(s=="STRAUSS" ) return IfcReflectanceMethodEnum::STRAUSS; + else if(s=="NOTDEFINED") return IfcReflectanceMethodEnum::NOTDEFINED; + else throw; +} +IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum IfcReinforcingBarRoleEnum::FromString(const std::string& s){ + if (s=="MAIN" ) return IfcReinforcingBarRoleEnum::MAIN; + else if(s=="SHEAR" ) return IfcReinforcingBarRoleEnum::SHEAR; + else if(s=="LIGATURE" ) return IfcReinforcingBarRoleEnum::LIGATURE; + else if(s=="STUD" ) return IfcReinforcingBarRoleEnum::STUD; + else if(s=="PUNCHING" ) return IfcReinforcingBarRoleEnum::PUNCHING; + else if(s=="EDGE" ) return IfcReinforcingBarRoleEnum::EDGE; + else if(s=="RING" ) return IfcReinforcingBarRoleEnum::RING; + else if(s=="USERDEFINED") return IfcReinforcingBarRoleEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcReinforcingBarRoleEnum::NOTDEFINED; + else throw; +} +IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcingBarSurfaceEnum::FromString(const std::string& s){ + if (s=="PLAIN" ) return IfcReinforcingBarSurfaceEnum::PLAIN; + else if(s=="TEXTURED") return IfcReinforcingBarSurfaceEnum::TEXTURED; + else throw; +} +IfcResourceConsumptionEnum::IfcResourceConsumptionEnum IfcResourceConsumptionEnum::FromString(const std::string& s){ + if (s=="CONSUMED" ) return IfcResourceConsumptionEnum::CONSUMED; + else if(s=="PARTIALLYCONSUMED") return IfcResourceConsumptionEnum::PARTIALLYCONSUMED; + else if(s=="NOTCONSUMED" ) return IfcResourceConsumptionEnum::NOTCONSUMED; + else if(s=="OCCUPIED" ) return IfcResourceConsumptionEnum::OCCUPIED; + else if(s=="PARTIALLYOCCUPIED") return IfcResourceConsumptionEnum::PARTIALLYOCCUPIED; + else if(s=="NOTOCCUPIED" ) return IfcResourceConsumptionEnum::NOTOCCUPIED; + else if(s=="USERDEFINED" ) return IfcResourceConsumptionEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcResourceConsumptionEnum::NOTDEFINED; + else throw; +} +IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum IfcRibPlateDirectionEnum::FromString(const std::string& s){ + if (s=="DIRECTION_X") return IfcRibPlateDirectionEnum::DIRECTION_X; + else if(s=="DIRECTION_Y") return IfcRibPlateDirectionEnum::DIRECTION_Y; + else throw; +} +IfcRoleEnum::IfcRoleEnum IfcRoleEnum::FromString(const std::string& s){ + if (s=="SUPPLIER" ) return IfcRoleEnum::SUPPLIER; + else if(s=="MANUFACTURER" ) return IfcRoleEnum::MANUFACTURER; + else if(s=="CONTRACTOR" ) return IfcRoleEnum::CONTRACTOR; + else if(s=="SUBCONTRACTOR" ) return IfcRoleEnum::SUBCONTRACTOR; + else if(s=="ARCHITECT" ) return IfcRoleEnum::ARCHITECT; + else if(s=="STRUCTURALENGINEER" ) return IfcRoleEnum::STRUCTURALENGINEER; + else if(s=="COSTENGINEER" ) return IfcRoleEnum::COSTENGINEER; + else if(s=="CLIENT" ) return IfcRoleEnum::CLIENT; + else if(s=="BUILDINGOWNER" ) return IfcRoleEnum::BUILDINGOWNER; + else if(s=="BUILDINGOPERATOR" ) return IfcRoleEnum::BUILDINGOPERATOR; + else if(s=="MECHANICALENGINEER" ) return IfcRoleEnum::MECHANICALENGINEER; + else if(s=="ELECTRICALENGINEER" ) return IfcRoleEnum::ELECTRICALENGINEER; + else if(s=="PROJECTMANAGER" ) return IfcRoleEnum::PROJECTMANAGER; + else if(s=="FACILITIESMANAGER" ) return IfcRoleEnum::FACILITIESMANAGER; + else if(s=="CIVILENGINEER" ) return IfcRoleEnum::CIVILENGINEER; + else if(s=="COMISSIONINGENGINEER" ) return IfcRoleEnum::COMISSIONINGENGINEER; + else if(s=="ENGINEER" ) return IfcRoleEnum::ENGINEER; + else if(s=="OWNER" ) return IfcRoleEnum::OWNER; + else if(s=="CONSULTANT" ) return IfcRoleEnum::CONSULTANT; + else if(s=="CONSTRUCTIONMANAGER" ) return IfcRoleEnum::CONSTRUCTIONMANAGER; + else if(s=="FIELDCONSTRUCTIONMANAGER") return IfcRoleEnum::FIELDCONSTRUCTIONMANAGER; + else if(s=="RESELLER" ) return IfcRoleEnum::RESELLER; + else if(s=="USERDEFINED" ) return IfcRoleEnum::USERDEFINED; + else throw; +} +IfcRoofTypeEnum::IfcRoofTypeEnum IfcRoofTypeEnum::FromString(const std::string& s){ + if (s=="FLAT_ROOF" ) return IfcRoofTypeEnum::FLAT_ROOF; + else if(s=="SHED_ROOF" ) return IfcRoofTypeEnum::SHED_ROOF; + else if(s=="GABLE_ROOF" ) return IfcRoofTypeEnum::GABLE_ROOF; + else if(s=="HIP_ROOF" ) return IfcRoofTypeEnum::HIP_ROOF; + else if(s=="HIPPED_GABLE_ROOF") return IfcRoofTypeEnum::HIPPED_GABLE_ROOF; + else if(s=="GAMBREL_ROOF" ) return IfcRoofTypeEnum::GAMBREL_ROOF; + else if(s=="MANSARD_ROOF" ) return IfcRoofTypeEnum::MANSARD_ROOF; + else if(s=="BARREL_ROOF" ) return IfcRoofTypeEnum::BARREL_ROOF; + else if(s=="RAINBOW_ROOF" ) return IfcRoofTypeEnum::RAINBOW_ROOF; + else if(s=="BUTTERFLY_ROOF" ) return IfcRoofTypeEnum::BUTTERFLY_ROOF; + else if(s=="PAVILION_ROOF" ) return IfcRoofTypeEnum::PAVILION_ROOF; + else if(s=="DOME_ROOF" ) return IfcRoofTypeEnum::DOME_ROOF; + else if(s=="FREEFORM" ) return IfcRoofTypeEnum::FREEFORM; + else if(s=="NOTDEFINED" ) return IfcRoofTypeEnum::NOTDEFINED; + else throw; +} +IfcSIPrefix::IfcSIPrefix IfcSIPrefix::FromString(const std::string& s){ + if (s=="EXA" ) return IfcSIPrefix::EXA; + else if(s=="PETA" ) return IfcSIPrefix::PETA; + else if(s=="TERA" ) return IfcSIPrefix::TERA; + else if(s=="GIGA" ) return IfcSIPrefix::GIGA; + else if(s=="MEGA" ) return IfcSIPrefix::MEGA; + else if(s=="KILO" ) return IfcSIPrefix::KILO; + else if(s=="HECTO") return IfcSIPrefix::HECTO; + else if(s=="DECA" ) return IfcSIPrefix::DECA; + else if(s=="DECI" ) return IfcSIPrefix::DECI; + else if(s=="CENTI") return IfcSIPrefix::CENTI; + else if(s=="MILLI") return IfcSIPrefix::MILLI; + else if(s=="MICRO") return IfcSIPrefix::MICRO; + else if(s=="NANO" ) return IfcSIPrefix::NANO; + else if(s=="PICO" ) return IfcSIPrefix::PICO; + else if(s=="FEMTO") return IfcSIPrefix::FEMTO; + else if(s=="ATTO" ) return IfcSIPrefix::ATTO; + else throw; +} +IfcSIUnitName::IfcSIUnitName IfcSIUnitName::FromString(const std::string& s){ + if (s=="AMPERE" ) return IfcSIUnitName::AMPERE; + else if(s=="BECQUEREL" ) return IfcSIUnitName::BECQUEREL; + else if(s=="CANDELA" ) return IfcSIUnitName::CANDELA; + else if(s=="COULOMB" ) return IfcSIUnitName::COULOMB; + else if(s=="CUBIC_METRE" ) return IfcSIUnitName::CUBIC_METRE; + else if(s=="DEGREE_CELSIUS") return IfcSIUnitName::DEGREE_CELSIUS; + else if(s=="FARAD" ) return IfcSIUnitName::FARAD; + else if(s=="GRAM" ) return IfcSIUnitName::GRAM; + else if(s=="GRAY" ) return IfcSIUnitName::GRAY; + else if(s=="HENRY" ) return IfcSIUnitName::HENRY; + else if(s=="HERTZ" ) return IfcSIUnitName::HERTZ; + else if(s=="JOULE" ) return IfcSIUnitName::JOULE; + else if(s=="KELVIN" ) return IfcSIUnitName::KELVIN; + else if(s=="LUMEN" ) return IfcSIUnitName::LUMEN; + else if(s=="LUX" ) return IfcSIUnitName::LUX; + else if(s=="METRE" ) return IfcSIUnitName::METRE; + else if(s=="MOLE" ) return IfcSIUnitName::MOLE; + else if(s=="NEWTON" ) return IfcSIUnitName::NEWTON; + else if(s=="OHM" ) return IfcSIUnitName::OHM; + else if(s=="PASCAL" ) return IfcSIUnitName::PASCAL; + else if(s=="RADIAN" ) return IfcSIUnitName::RADIAN; + else if(s=="SECOND" ) return IfcSIUnitName::SECOND; + else if(s=="SIEMENS" ) return IfcSIUnitName::SIEMENS; + else if(s=="SIEVERT" ) return IfcSIUnitName::SIEVERT; + else if(s=="SQUARE_METRE" ) return IfcSIUnitName::SQUARE_METRE; + else if(s=="STERADIAN" ) return IfcSIUnitName::STERADIAN; + else if(s=="TESLA" ) return IfcSIUnitName::TESLA; + else if(s=="VOLT" ) return IfcSIUnitName::VOLT; + else if(s=="WATT" ) return IfcSIUnitName::WATT; + else if(s=="WEBER" ) return IfcSIUnitName::WEBER; + else throw; +} +IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum IfcSanitaryTerminalTypeEnum::FromString(const std::string& s){ + if (s=="BATH" ) return IfcSanitaryTerminalTypeEnum::BATH; + else if(s=="BIDET" ) return IfcSanitaryTerminalTypeEnum::BIDET; + else if(s=="CISTERN" ) return IfcSanitaryTerminalTypeEnum::CISTERN; + else if(s=="SHOWER" ) return IfcSanitaryTerminalTypeEnum::SHOWER; + else if(s=="SINK" ) return IfcSanitaryTerminalTypeEnum::SINK; + else if(s=="SANITARYFOUNTAIN") return IfcSanitaryTerminalTypeEnum::SANITARYFOUNTAIN; + else if(s=="TOILETPAN" ) return IfcSanitaryTerminalTypeEnum::TOILETPAN; + else if(s=="URINAL" ) return IfcSanitaryTerminalTypeEnum::URINAL; + else if(s=="WASHHANDBASIN" ) return IfcSanitaryTerminalTypeEnum::WASHHANDBASIN; + else if(s=="WCSEAT" ) return IfcSanitaryTerminalTypeEnum::WCSEAT; + else if(s=="USERDEFINED" ) return IfcSanitaryTerminalTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcSanitaryTerminalTypeEnum::NOTDEFINED; + else throw; +} +IfcSectionTypeEnum::IfcSectionTypeEnum IfcSectionTypeEnum::FromString(const std::string& s){ + if (s=="UNIFORM") return IfcSectionTypeEnum::UNIFORM; + else if(s=="TAPERED") return IfcSectionTypeEnum::TAPERED; + else throw; +} +IfcSensorTypeEnum::IfcSensorTypeEnum IfcSensorTypeEnum::FromString(const std::string& s){ + if (s=="CO2SENSOR" ) return IfcSensorTypeEnum::CO2SENSOR; + else if(s=="FIRESENSOR" ) return IfcSensorTypeEnum::FIRESENSOR; + else if(s=="FLOWSENSOR" ) return IfcSensorTypeEnum::FLOWSENSOR; + else if(s=="GASSENSOR" ) return IfcSensorTypeEnum::GASSENSOR; + else if(s=="HEATSENSOR" ) return IfcSensorTypeEnum::HEATSENSOR; + else if(s=="HUMIDITYSENSOR" ) return IfcSensorTypeEnum::HUMIDITYSENSOR; + else if(s=="LIGHTSENSOR" ) return IfcSensorTypeEnum::LIGHTSENSOR; + else if(s=="MOISTURESENSOR" ) return IfcSensorTypeEnum::MOISTURESENSOR; + else if(s=="MOVEMENTSENSOR" ) return IfcSensorTypeEnum::MOVEMENTSENSOR; + else if(s=="PRESSURESENSOR" ) return IfcSensorTypeEnum::PRESSURESENSOR; + else if(s=="SMOKESENSOR" ) return IfcSensorTypeEnum::SMOKESENSOR; + else if(s=="SOUNDSENSOR" ) return IfcSensorTypeEnum::SOUNDSENSOR; + else if(s=="TEMPERATURESENSOR") return IfcSensorTypeEnum::TEMPERATURESENSOR; + else if(s=="USERDEFINED" ) return IfcSensorTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcSensorTypeEnum::NOTDEFINED; + else throw; +} +IfcSequenceEnum::IfcSequenceEnum IfcSequenceEnum::FromString(const std::string& s){ + if (s=="START_START" ) return IfcSequenceEnum::START_START; + else if(s=="START_FINISH" ) return IfcSequenceEnum::START_FINISH; + else if(s=="FINISH_START" ) return IfcSequenceEnum::FINISH_START; + else if(s=="FINISH_FINISH") return IfcSequenceEnum::FINISH_FINISH; + else if(s=="NOTDEFINED" ) return IfcSequenceEnum::NOTDEFINED; + else throw; +} +IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum IfcServiceLifeFactorTypeEnum::FromString(const std::string& s){ + if (s=="A_QUALITYOFCOMPONENTS") return IfcServiceLifeFactorTypeEnum::A_QUALITYOFCOMPONENTS; + else if(s=="B_DESIGNLEVEL" ) return IfcServiceLifeFactorTypeEnum::B_DESIGNLEVEL; + else if(s=="C_WORKEXECUTIONLEVEL" ) return IfcServiceLifeFactorTypeEnum::C_WORKEXECUTIONLEVEL; + else if(s=="D_INDOORENVIRONMENT" ) return IfcServiceLifeFactorTypeEnum::D_INDOORENVIRONMENT; + else if(s=="E_OUTDOORENVIRONMENT" ) return IfcServiceLifeFactorTypeEnum::E_OUTDOORENVIRONMENT; + else if(s=="F_INUSECONDITIONS" ) return IfcServiceLifeFactorTypeEnum::F_INUSECONDITIONS; + else if(s=="G_MAINTENANCELEVEL" ) return IfcServiceLifeFactorTypeEnum::G_MAINTENANCELEVEL; + else if(s=="USERDEFINED" ) return IfcServiceLifeFactorTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcServiceLifeFactorTypeEnum::NOTDEFINED; + else throw; +} +IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum IfcServiceLifeTypeEnum::FromString(const std::string& s){ + if (s=="ACTUALSERVICELIFE" ) return IfcServiceLifeTypeEnum::ACTUALSERVICELIFE; + else if(s=="EXPECTEDSERVICELIFE" ) return IfcServiceLifeTypeEnum::EXPECTEDSERVICELIFE; + else if(s=="OPTIMISTICREFERENCESERVICELIFE" ) return IfcServiceLifeTypeEnum::OPTIMISTICREFERENCESERVICELIFE; + else if(s=="PESSIMISTICREFERENCESERVICELIFE") return IfcServiceLifeTypeEnum::PESSIMISTICREFERENCESERVICELIFE; + else if(s=="REFERENCESERVICELIFE" ) return IfcServiceLifeTypeEnum::REFERENCESERVICELIFE; + else throw; +} +IfcSlabTypeEnum::IfcSlabTypeEnum IfcSlabTypeEnum::FromString(const std::string& s){ + if (s=="FLOOR" ) return IfcSlabTypeEnum::FLOOR; + else if(s=="ROOF" ) return IfcSlabTypeEnum::ROOF; + else if(s=="LANDING" ) return IfcSlabTypeEnum::LANDING; + else if(s=="BASESLAB" ) return IfcSlabTypeEnum::BASESLAB; + else if(s=="USERDEFINED") return IfcSlabTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcSlabTypeEnum::NOTDEFINED; + else throw; +} +IfcSoundScaleEnum::IfcSoundScaleEnum IfcSoundScaleEnum::FromString(const std::string& s){ + if (s=="DBA" ) return IfcSoundScaleEnum::DBA; + else if(s=="DBB" ) return IfcSoundScaleEnum::DBB; + else if(s=="DBC" ) return IfcSoundScaleEnum::DBC; + else if(s=="NC" ) return IfcSoundScaleEnum::NC; + else if(s=="NR" ) return IfcSoundScaleEnum::NR; + else if(s=="USERDEFINED") return IfcSoundScaleEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcSoundScaleEnum::NOTDEFINED; + else throw; +} +IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum IfcSpaceHeaterTypeEnum::FromString(const std::string& s){ + if (s=="SECTIONALRADIATOR") return IfcSpaceHeaterTypeEnum::SECTIONALRADIATOR; + else if(s=="PANELRADIATOR" ) return IfcSpaceHeaterTypeEnum::PANELRADIATOR; + else if(s=="TUBULARRADIATOR" ) return IfcSpaceHeaterTypeEnum::TUBULARRADIATOR; + else if(s=="CONVECTOR" ) return IfcSpaceHeaterTypeEnum::CONVECTOR; + else if(s=="BASEBOARDHEATER" ) return IfcSpaceHeaterTypeEnum::BASEBOARDHEATER; + else if(s=="FINNEDTUBEUNIT" ) return IfcSpaceHeaterTypeEnum::FINNEDTUBEUNIT; + else if(s=="UNITHEATER" ) return IfcSpaceHeaterTypeEnum::UNITHEATER; + else if(s=="USERDEFINED" ) return IfcSpaceHeaterTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcSpaceHeaterTypeEnum::NOTDEFINED; + else throw; +} +IfcSpaceTypeEnum::IfcSpaceTypeEnum IfcSpaceTypeEnum::FromString(const std::string& s){ + if (s=="USERDEFINED") return IfcSpaceTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcSpaceTypeEnum::NOTDEFINED; + else throw; +} +IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum IfcStackTerminalTypeEnum::FromString(const std::string& s){ + if (s=="BIRDCAGE" ) return IfcStackTerminalTypeEnum::BIRDCAGE; + else if(s=="COWL" ) return IfcStackTerminalTypeEnum::COWL; + else if(s=="RAINWATERHOPPER") return IfcStackTerminalTypeEnum::RAINWATERHOPPER; + else if(s=="USERDEFINED" ) return IfcStackTerminalTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcStackTerminalTypeEnum::NOTDEFINED; + else throw; +} +IfcStairFlightTypeEnum::IfcStairFlightTypeEnum IfcStairFlightTypeEnum::FromString(const std::string& s){ + if (s=="STRAIGHT" ) return IfcStairFlightTypeEnum::STRAIGHT; + else if(s=="WINDER" ) return IfcStairFlightTypeEnum::WINDER; + else if(s=="SPIRAL" ) return IfcStairFlightTypeEnum::SPIRAL; + else if(s=="CURVED" ) return IfcStairFlightTypeEnum::CURVED; + else if(s=="FREEFORM" ) return IfcStairFlightTypeEnum::FREEFORM; + else if(s=="USERDEFINED") return IfcStairFlightTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcStairFlightTypeEnum::NOTDEFINED; + else throw; +} +IfcStairTypeEnum::IfcStairTypeEnum IfcStairTypeEnum::FromString(const std::string& s){ + if (s=="STRAIGHT_RUN_STAIR" ) return IfcStairTypeEnum::STRAIGHT_RUN_STAIR; + else if(s=="TWO_STRAIGHT_RUN_STAIR" ) return IfcStairTypeEnum::TWO_STRAIGHT_RUN_STAIR; + else if(s=="QUARTER_WINDING_STAIR" ) return IfcStairTypeEnum::QUARTER_WINDING_STAIR; + else if(s=="QUARTER_TURN_STAIR" ) return IfcStairTypeEnum::QUARTER_TURN_STAIR; + else if(s=="HALF_WINDING_STAIR" ) return IfcStairTypeEnum::HALF_WINDING_STAIR; + else if(s=="HALF_TURN_STAIR" ) return IfcStairTypeEnum::HALF_TURN_STAIR; + else if(s=="TWO_QUARTER_WINDING_STAIR" ) return IfcStairTypeEnum::TWO_QUARTER_WINDING_STAIR; + else if(s=="TWO_QUARTER_TURN_STAIR" ) return IfcStairTypeEnum::TWO_QUARTER_TURN_STAIR; + else if(s=="THREE_QUARTER_WINDING_STAIR") return IfcStairTypeEnum::THREE_QUARTER_WINDING_STAIR; + else if(s=="THREE_QUARTER_TURN_STAIR" ) return IfcStairTypeEnum::THREE_QUARTER_TURN_STAIR; + else if(s=="SPIRAL_STAIR" ) return IfcStairTypeEnum::SPIRAL_STAIR; + else if(s=="DOUBLE_RETURN_STAIR" ) return IfcStairTypeEnum::DOUBLE_RETURN_STAIR; + else if(s=="CURVED_RUN_STAIR" ) return IfcStairTypeEnum::CURVED_RUN_STAIR; + else if(s=="TWO_CURVED_RUN_STAIR" ) return IfcStairTypeEnum::TWO_CURVED_RUN_STAIR; + else if(s=="USERDEFINED" ) return IfcStairTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcStairTypeEnum::NOTDEFINED; + else throw; +} +IfcStateEnum::IfcStateEnum IfcStateEnum::FromString(const std::string& s){ + if (s=="READWRITE" ) return IfcStateEnum::READWRITE; + else if(s=="READONLY" ) return IfcStateEnum::READONLY; + else if(s=="LOCKED" ) return IfcStateEnum::LOCKED; + else if(s=="READWRITELOCKED") return IfcStateEnum::READWRITELOCKED; + else if(s=="READONLYLOCKED" ) return IfcStateEnum::READONLYLOCKED; + else throw; +} +IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum IfcStructuralCurveTypeEnum::FromString(const std::string& s){ + if (s=="RIGID_JOINED_MEMBER") return IfcStructuralCurveTypeEnum::RIGID_JOINED_MEMBER; + else if(s=="PIN_JOINED_MEMBER" ) return IfcStructuralCurveTypeEnum::PIN_JOINED_MEMBER; + else if(s=="CABLE" ) return IfcStructuralCurveTypeEnum::CABLE; + else if(s=="TENSION_MEMBER" ) return IfcStructuralCurveTypeEnum::TENSION_MEMBER; + else if(s=="COMPRESSION_MEMBER" ) return IfcStructuralCurveTypeEnum::COMPRESSION_MEMBER; + else if(s=="USERDEFINED" ) return IfcStructuralCurveTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcStructuralCurveTypeEnum::NOTDEFINED; + else throw; +} +IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum IfcStructuralSurfaceTypeEnum::FromString(const std::string& s){ + if (s=="BENDING_ELEMENT" ) return IfcStructuralSurfaceTypeEnum::BENDING_ELEMENT; + else if(s=="MEMBRANE_ELEMENT") return IfcStructuralSurfaceTypeEnum::MEMBRANE_ELEMENT; + else if(s=="SHELL" ) return IfcStructuralSurfaceTypeEnum::SHELL; + else if(s=="USERDEFINED" ) return IfcStructuralSurfaceTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcStructuralSurfaceTypeEnum::NOTDEFINED; + else throw; +} +IfcSurfaceSide::IfcSurfaceSide IfcSurfaceSide::FromString(const std::string& s){ + if (s=="POSITIVE") return IfcSurfaceSide::POSITIVE; + else if(s=="NEGATIVE") return IfcSurfaceSide::NEGATIVE; + else if(s=="BOTH" ) return IfcSurfaceSide::BOTH; + else throw; +} +IfcSurfaceTextureEnum::IfcSurfaceTextureEnum IfcSurfaceTextureEnum::FromString(const std::string& s){ + if (s=="BUMP" ) return IfcSurfaceTextureEnum::BUMP; + else if(s=="OPACITY" ) return IfcSurfaceTextureEnum::OPACITY; + else if(s=="REFLECTION" ) return IfcSurfaceTextureEnum::REFLECTION; + else if(s=="SELFILLUMINATION") return IfcSurfaceTextureEnum::SELFILLUMINATION; + else if(s=="SHININESS" ) return IfcSurfaceTextureEnum::SHININESS; + else if(s=="SPECULAR" ) return IfcSurfaceTextureEnum::SPECULAR; + else if(s=="TEXTURE" ) return IfcSurfaceTextureEnum::TEXTURE; + else if(s=="TRANSPARENCYMAP" ) return IfcSurfaceTextureEnum::TRANSPARENCYMAP; + else if(s=="NOTDEFINED" ) return IfcSurfaceTextureEnum::NOTDEFINED; + else throw; +} +IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum IfcSwitchingDeviceTypeEnum::FromString(const std::string& s){ + if (s=="CONTACTOR" ) return IfcSwitchingDeviceTypeEnum::CONTACTOR; + else if(s=="EMERGENCYSTOP" ) return IfcSwitchingDeviceTypeEnum::EMERGENCYSTOP; + else if(s=="STARTER" ) return IfcSwitchingDeviceTypeEnum::STARTER; + else if(s=="SWITCHDISCONNECTOR") return IfcSwitchingDeviceTypeEnum::SWITCHDISCONNECTOR; + else if(s=="TOGGLESWITCH" ) return IfcSwitchingDeviceTypeEnum::TOGGLESWITCH; + else if(s=="USERDEFINED" ) return IfcSwitchingDeviceTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcSwitchingDeviceTypeEnum::NOTDEFINED; + else throw; +} +IfcTankTypeEnum::IfcTankTypeEnum IfcTankTypeEnum::FromString(const std::string& s){ + if (s=="PREFORMED" ) return IfcTankTypeEnum::PREFORMED; + else if(s=="SECTIONAL" ) return IfcTankTypeEnum::SECTIONAL; + else if(s=="EXPANSION" ) return IfcTankTypeEnum::EXPANSION; + else if(s=="PRESSUREVESSEL") return IfcTankTypeEnum::PRESSUREVESSEL; + else if(s=="USERDEFINED" ) return IfcTankTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcTankTypeEnum::NOTDEFINED; + else throw; +} +IfcTendonTypeEnum::IfcTendonTypeEnum IfcTendonTypeEnum::FromString(const std::string& s){ + if (s=="STRAND" ) return IfcTendonTypeEnum::STRAND; + else if(s=="WIRE" ) return IfcTendonTypeEnum::WIRE; + else if(s=="BAR" ) return IfcTendonTypeEnum::BAR; + else if(s=="COATED" ) return IfcTendonTypeEnum::COATED; + else if(s=="USERDEFINED") return IfcTendonTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcTendonTypeEnum::NOTDEFINED; + else throw; +} +IfcTextPath::IfcTextPath IfcTextPath::FromString(const std::string& s){ + if (s=="LEFT" ) return IfcTextPath::LEFT; + else if(s=="RIGHT") return IfcTextPath::RIGHT; + else if(s=="UP" ) return IfcTextPath::UP; + else if(s=="DOWN" ) return IfcTextPath::DOWN; + else throw; +} +IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum IfcThermalLoadSourceEnum::FromString(const std::string& s){ + if (s=="PEOPLE" ) return IfcThermalLoadSourceEnum::PEOPLE; + else if(s=="LIGHTING" ) return IfcThermalLoadSourceEnum::LIGHTING; + else if(s=="EQUIPMENT" ) return IfcThermalLoadSourceEnum::EQUIPMENT; + else if(s=="VENTILATIONINDOORAIR" ) return IfcThermalLoadSourceEnum::VENTILATIONINDOORAIR; + else if(s=="VENTILATIONOUTSIDEAIR") return IfcThermalLoadSourceEnum::VENTILATIONOUTSIDEAIR; + else if(s=="RECIRCULATEDAIR" ) return IfcThermalLoadSourceEnum::RECIRCULATEDAIR; + else if(s=="EXHAUSTAIR" ) return IfcThermalLoadSourceEnum::EXHAUSTAIR; + else if(s=="AIREXCHANGERATE" ) return IfcThermalLoadSourceEnum::AIREXCHANGERATE; + else if(s=="DRYBULBTEMPERATURE" ) return IfcThermalLoadSourceEnum::DRYBULBTEMPERATURE; + else if(s=="RELATIVEHUMIDITY" ) return IfcThermalLoadSourceEnum::RELATIVEHUMIDITY; + else if(s=="INFILTRATION" ) return IfcThermalLoadSourceEnum::INFILTRATION; + else if(s=="USERDEFINED" ) return IfcThermalLoadSourceEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcThermalLoadSourceEnum::NOTDEFINED; + else throw; +} +IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum IfcThermalLoadTypeEnum::FromString(const std::string& s){ + if (s=="SENSIBLE" ) return IfcThermalLoadTypeEnum::SENSIBLE; + else if(s=="LATENT" ) return IfcThermalLoadTypeEnum::LATENT; + else if(s=="RADIANT" ) return IfcThermalLoadTypeEnum::RADIANT; + else if(s=="NOTDEFINED") return IfcThermalLoadTypeEnum::NOTDEFINED; + else throw; +} +IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum IfcTimeSeriesDataTypeEnum::FromString(const std::string& s){ + if (s=="CONTINUOUS" ) return IfcTimeSeriesDataTypeEnum::CONTINUOUS; + else if(s=="DISCRETE" ) return IfcTimeSeriesDataTypeEnum::DISCRETE; + else if(s=="DISCRETEBINARY" ) return IfcTimeSeriesDataTypeEnum::DISCRETEBINARY; + else if(s=="PIECEWISEBINARY" ) return IfcTimeSeriesDataTypeEnum::PIECEWISEBINARY; + else if(s=="PIECEWISECONSTANT" ) return IfcTimeSeriesDataTypeEnum::PIECEWISECONSTANT; + else if(s=="PIECEWISECONTINUOUS") return IfcTimeSeriesDataTypeEnum::PIECEWISECONTINUOUS; + else if(s=="NOTDEFINED" ) return IfcTimeSeriesDataTypeEnum::NOTDEFINED; + else throw; +} +IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum IfcTimeSeriesScheduleTypeEnum::FromString(const std::string& s){ + if (s=="ANNUAL" ) return IfcTimeSeriesScheduleTypeEnum::ANNUAL; + else if(s=="MONTHLY" ) return IfcTimeSeriesScheduleTypeEnum::MONTHLY; + else if(s=="WEEKLY" ) return IfcTimeSeriesScheduleTypeEnum::WEEKLY; + else if(s=="DAILY" ) return IfcTimeSeriesScheduleTypeEnum::DAILY; + else if(s=="USERDEFINED") return IfcTimeSeriesScheduleTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcTimeSeriesScheduleTypeEnum::NOTDEFINED; + else throw; +} +IfcTransformerTypeEnum::IfcTransformerTypeEnum IfcTransformerTypeEnum::FromString(const std::string& s){ + if (s=="CURRENT" ) return IfcTransformerTypeEnum::CURRENT; + else if(s=="FREQUENCY" ) return IfcTransformerTypeEnum::FREQUENCY; + else if(s=="VOLTAGE" ) return IfcTransformerTypeEnum::VOLTAGE; + else if(s=="USERDEFINED") return IfcTransformerTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcTransformerTypeEnum::NOTDEFINED; + else throw; +} +IfcTransitionCode::IfcTransitionCode IfcTransitionCode::FromString(const std::string& s){ + if (s=="DISCONTINUOUS" ) return IfcTransitionCode::DISCONTINUOUS; + else if(s=="CONTINUOUS" ) return IfcTransitionCode::CONTINUOUS; + else if(s=="CONTSAMEGRADIENT" ) return IfcTransitionCode::CONTSAMEGRADIENT; + else if(s=="CONTSAMEGRADIENTSAMECURVATURE") return IfcTransitionCode::CONTSAMEGRADIENTSAMECURVATURE; + else throw; +} +IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElementTypeEnum::FromString(const std::string& s){ + if (s=="ELEVATOR" ) return IfcTransportElementTypeEnum::ELEVATOR; + else if(s=="ESCALATOR" ) return IfcTransportElementTypeEnum::ESCALATOR; + else if(s=="MOVINGWALKWAY") return IfcTransportElementTypeEnum::MOVINGWALKWAY; + else if(s=="USERDEFINED" ) return IfcTransportElementTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcTransportElementTypeEnum::NOTDEFINED; + else throw; +} +IfcTrimmingPreference::IfcTrimmingPreference IfcTrimmingPreference::FromString(const std::string& s){ + if (s=="CARTESIAN" ) return IfcTrimmingPreference::CARTESIAN; + else if(s=="PARAMETER" ) return IfcTrimmingPreference::PARAMETER; + else if(s=="UNSPECIFIED") return IfcTrimmingPreference::UNSPECIFIED; + else throw; +} +IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum IfcTubeBundleTypeEnum::FromString(const std::string& s){ + if (s=="FINNED" ) return IfcTubeBundleTypeEnum::FINNED; + else if(s=="USERDEFINED") return IfcTubeBundleTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcTubeBundleTypeEnum::NOTDEFINED; + else throw; +} +IfcUnitEnum::IfcUnitEnum IfcUnitEnum::FromString(const std::string& s){ + if (s=="ABSORBEDDOSEUNIT" ) return IfcUnitEnum::ABSORBEDDOSEUNIT; + else if(s=="AMOUNTOFSUBSTANCEUNIT" ) return IfcUnitEnum::AMOUNTOFSUBSTANCEUNIT; + else if(s=="AREAUNIT" ) return IfcUnitEnum::AREAUNIT; + else if(s=="DOSEEQUIVALENTUNIT" ) return IfcUnitEnum::DOSEEQUIVALENTUNIT; + else if(s=="ELECTRICCAPACITANCEUNIT" ) return IfcUnitEnum::ELECTRICCAPACITANCEUNIT; + else if(s=="ELECTRICCHARGEUNIT" ) return IfcUnitEnum::ELECTRICCHARGEUNIT; + else if(s=="ELECTRICCONDUCTANCEUNIT" ) return IfcUnitEnum::ELECTRICCONDUCTANCEUNIT; + else if(s=="ELECTRICCURRENTUNIT" ) return IfcUnitEnum::ELECTRICCURRENTUNIT; + else if(s=="ELECTRICRESISTANCEUNIT" ) return IfcUnitEnum::ELECTRICRESISTANCEUNIT; + else if(s=="ELECTRICVOLTAGEUNIT" ) return IfcUnitEnum::ELECTRICVOLTAGEUNIT; + else if(s=="ENERGYUNIT" ) return IfcUnitEnum::ENERGYUNIT; + else if(s=="FORCEUNIT" ) return IfcUnitEnum::FORCEUNIT; + else if(s=="FREQUENCYUNIT" ) return IfcUnitEnum::FREQUENCYUNIT; + else if(s=="ILLUMINANCEUNIT" ) return IfcUnitEnum::ILLUMINANCEUNIT; + else if(s=="INDUCTANCEUNIT" ) return IfcUnitEnum::INDUCTANCEUNIT; + else if(s=="LENGTHUNIT" ) return IfcUnitEnum::LENGTHUNIT; + else if(s=="LUMINOUSFLUXUNIT" ) return IfcUnitEnum::LUMINOUSFLUXUNIT; + else if(s=="LUMINOUSINTENSITYUNIT" ) return IfcUnitEnum::LUMINOUSINTENSITYUNIT; + else if(s=="MAGNETICFLUXDENSITYUNIT" ) return IfcUnitEnum::MAGNETICFLUXDENSITYUNIT; + else if(s=="MAGNETICFLUXUNIT" ) return IfcUnitEnum::MAGNETICFLUXUNIT; + else if(s=="MASSUNIT" ) return IfcUnitEnum::MASSUNIT; + else if(s=="PLANEANGLEUNIT" ) return IfcUnitEnum::PLANEANGLEUNIT; + else if(s=="POWERUNIT" ) return IfcUnitEnum::POWERUNIT; + else if(s=="PRESSUREUNIT" ) return IfcUnitEnum::PRESSUREUNIT; + else if(s=="RADIOACTIVITYUNIT" ) return IfcUnitEnum::RADIOACTIVITYUNIT; + else if(s=="SOLIDANGLEUNIT" ) return IfcUnitEnum::SOLIDANGLEUNIT; + else if(s=="THERMODYNAMICTEMPERATUREUNIT") return IfcUnitEnum::THERMODYNAMICTEMPERATUREUNIT; + else if(s=="TIMEUNIT" ) return IfcUnitEnum::TIMEUNIT; + else if(s=="VOLUMEUNIT" ) return IfcUnitEnum::VOLUMEUNIT; + else if(s=="USERDEFINED" ) return IfcUnitEnum::USERDEFINED; + else throw; +} +IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum IfcUnitaryEquipmentTypeEnum::FromString(const std::string& s){ + if (s=="AIRHANDLER" ) return IfcUnitaryEquipmentTypeEnum::AIRHANDLER; + else if(s=="AIRCONDITIONINGUNIT") return IfcUnitaryEquipmentTypeEnum::AIRCONDITIONINGUNIT; + else if(s=="SPLITSYSTEM" ) return IfcUnitaryEquipmentTypeEnum::SPLITSYSTEM; + else if(s=="ROOFTOPUNIT" ) return IfcUnitaryEquipmentTypeEnum::ROOFTOPUNIT; + else if(s=="USERDEFINED" ) return IfcUnitaryEquipmentTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcUnitaryEquipmentTypeEnum::NOTDEFINED; + else throw; +} +IfcValveTypeEnum::IfcValveTypeEnum IfcValveTypeEnum::FromString(const std::string& s){ + if (s=="AIRRELEASE" ) return IfcValveTypeEnum::AIRRELEASE; + else if(s=="ANTIVACUUM" ) return IfcValveTypeEnum::ANTIVACUUM; + else if(s=="CHANGEOVER" ) return IfcValveTypeEnum::CHANGEOVER; + else if(s=="CHECK" ) return IfcValveTypeEnum::CHECK; + else if(s=="COMMISSIONING" ) return IfcValveTypeEnum::COMMISSIONING; + else if(s=="DIVERTING" ) return IfcValveTypeEnum::DIVERTING; + else if(s=="DRAWOFFCOCK" ) return IfcValveTypeEnum::DRAWOFFCOCK; + else if(s=="DOUBLECHECK" ) return IfcValveTypeEnum::DOUBLECHECK; + else if(s=="DOUBLEREGULATING") return IfcValveTypeEnum::DOUBLEREGULATING; + else if(s=="FAUCET" ) return IfcValveTypeEnum::FAUCET; + else if(s=="FLUSHING" ) return IfcValveTypeEnum::FLUSHING; + else if(s=="GASCOCK" ) return IfcValveTypeEnum::GASCOCK; + else if(s=="GASTAP" ) return IfcValveTypeEnum::GASTAP; + else if(s=="ISOLATING" ) return IfcValveTypeEnum::ISOLATING; + else if(s=="MIXING" ) return IfcValveTypeEnum::MIXING; + else if(s=="PRESSUREREDUCING") return IfcValveTypeEnum::PRESSUREREDUCING; + else if(s=="PRESSURERELIEF" ) return IfcValveTypeEnum::PRESSURERELIEF; + else if(s=="REGULATING" ) return IfcValveTypeEnum::REGULATING; + else if(s=="SAFETYCUTOFF" ) return IfcValveTypeEnum::SAFETYCUTOFF; + else if(s=="STEAMTRAP" ) return IfcValveTypeEnum::STEAMTRAP; + else if(s=="STOPCOCK" ) return IfcValveTypeEnum::STOPCOCK; + else if(s=="USERDEFINED" ) return IfcValveTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcValveTypeEnum::NOTDEFINED; + else throw; +} +IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum IfcVibrationIsolatorTypeEnum::FromString(const std::string& s){ + if (s=="COMPRESSION") return IfcVibrationIsolatorTypeEnum::COMPRESSION; + else if(s=="SPRING" ) return IfcVibrationIsolatorTypeEnum::SPRING; + else if(s=="USERDEFINED") return IfcVibrationIsolatorTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcVibrationIsolatorTypeEnum::NOTDEFINED; + else throw; +} +IfcWallTypeEnum::IfcWallTypeEnum IfcWallTypeEnum::FromString(const std::string& s){ + if (s=="STANDARD" ) return IfcWallTypeEnum::STANDARD; + else if(s=="POLYGONAL" ) return IfcWallTypeEnum::POLYGONAL; + else if(s=="SHEAR" ) return IfcWallTypeEnum::SHEAR; + else if(s=="ELEMENTEDWALL") return IfcWallTypeEnum::ELEMENTEDWALL; + else if(s=="PLUMBINGWALL" ) return IfcWallTypeEnum::PLUMBINGWALL; + else if(s=="USERDEFINED" ) return IfcWallTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcWallTypeEnum::NOTDEFINED; + else throw; +} +IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum IfcWasteTerminalTypeEnum::FromString(const std::string& s){ + if (s=="FLOORTRAP" ) return IfcWasteTerminalTypeEnum::FLOORTRAP; + else if(s=="FLOORWASTE" ) return IfcWasteTerminalTypeEnum::FLOORWASTE; + else if(s=="GULLYSUMP" ) return IfcWasteTerminalTypeEnum::GULLYSUMP; + else if(s=="GULLYTRAP" ) return IfcWasteTerminalTypeEnum::GULLYTRAP; + else if(s=="GREASEINTERCEPTOR") return IfcWasteTerminalTypeEnum::GREASEINTERCEPTOR; + else if(s=="OILINTERCEPTOR" ) return IfcWasteTerminalTypeEnum::OILINTERCEPTOR; + else if(s=="PETROLINTERCEPTOR") return IfcWasteTerminalTypeEnum::PETROLINTERCEPTOR; + else if(s=="ROOFDRAIN" ) return IfcWasteTerminalTypeEnum::ROOFDRAIN; + else if(s=="WASTEDISPOSALUNIT") return IfcWasteTerminalTypeEnum::WASTEDISPOSALUNIT; + else if(s=="WASTETRAP" ) return IfcWasteTerminalTypeEnum::WASTETRAP; + else if(s=="USERDEFINED" ) return IfcWasteTerminalTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcWasteTerminalTypeEnum::NOTDEFINED; + else throw; +} +IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum IfcWindowPanelOperationEnum::FromString(const std::string& s){ + if (s=="SIDEHUNGRIGHTHAND" ) return IfcWindowPanelOperationEnum::SIDEHUNGRIGHTHAND; + else if(s=="SIDEHUNGLEFTHAND" ) return IfcWindowPanelOperationEnum::SIDEHUNGLEFTHAND; + else if(s=="TILTANDTURNRIGHTHAND") return IfcWindowPanelOperationEnum::TILTANDTURNRIGHTHAND; + else if(s=="TILTANDTURNLEFTHAND" ) return IfcWindowPanelOperationEnum::TILTANDTURNLEFTHAND; + else if(s=="TOPHUNG" ) return IfcWindowPanelOperationEnum::TOPHUNG; + else if(s=="BOTTOMHUNG" ) return IfcWindowPanelOperationEnum::BOTTOMHUNG; + else if(s=="PIVOTHORIZONTAL" ) return IfcWindowPanelOperationEnum::PIVOTHORIZONTAL; + else if(s=="PIVOTVERTICAL" ) return IfcWindowPanelOperationEnum::PIVOTVERTICAL; + else if(s=="SLIDINGHORIZONTAL" ) return IfcWindowPanelOperationEnum::SLIDINGHORIZONTAL; + else if(s=="SLIDINGVERTICAL" ) return IfcWindowPanelOperationEnum::SLIDINGVERTICAL; + else if(s=="REMOVABLECASEMENT" ) return IfcWindowPanelOperationEnum::REMOVABLECASEMENT; + else if(s=="FIXEDCASEMENT" ) return IfcWindowPanelOperationEnum::FIXEDCASEMENT; + else if(s=="OTHEROPERATION" ) return IfcWindowPanelOperationEnum::OTHEROPERATION; + else if(s=="NOTDEFINED" ) return IfcWindowPanelOperationEnum::NOTDEFINED; + else throw; +} +IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum IfcWindowPanelPositionEnum::FromString(const std::string& s){ + if (s=="LEFT" ) return IfcWindowPanelPositionEnum::LEFT; + else if(s=="MIDDLE" ) return IfcWindowPanelPositionEnum::MIDDLE; + else if(s=="RIGHT" ) return IfcWindowPanelPositionEnum::RIGHT; + else if(s=="BOTTOM" ) return IfcWindowPanelPositionEnum::BOTTOM; + else if(s=="TOP" ) return IfcWindowPanelPositionEnum::TOP; + else if(s=="NOTDEFINED") return IfcWindowPanelPositionEnum::NOTDEFINED; + else throw; +} +IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum IfcWindowStyleConstructionEnum::FromString(const std::string& s){ + if (s=="ALUMINIUM" ) return IfcWindowStyleConstructionEnum::ALUMINIUM; + else if(s=="HIGH_GRADE_STEEL" ) return IfcWindowStyleConstructionEnum::HIGH_GRADE_STEEL; + else if(s=="STEEL" ) return IfcWindowStyleConstructionEnum::STEEL; + else if(s=="WOOD" ) return IfcWindowStyleConstructionEnum::WOOD; + else if(s=="ALUMINIUM_WOOD" ) return IfcWindowStyleConstructionEnum::ALUMINIUM_WOOD; + else if(s=="PLASTIC" ) return IfcWindowStyleConstructionEnum::PLASTIC; + else if(s=="OTHER_CONSTRUCTION") return IfcWindowStyleConstructionEnum::OTHER_CONSTRUCTION; + else if(s=="NOTDEFINED" ) return IfcWindowStyleConstructionEnum::NOTDEFINED; + else throw; +} +IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum IfcWindowStyleOperationEnum::FromString(const std::string& s){ + if (s=="SINGLE_PANEL" ) return IfcWindowStyleOperationEnum::SINGLE_PANEL; + else if(s=="DOUBLE_PANEL_VERTICAL" ) return IfcWindowStyleOperationEnum::DOUBLE_PANEL_VERTICAL; + else if(s=="DOUBLE_PANEL_HORIZONTAL") return IfcWindowStyleOperationEnum::DOUBLE_PANEL_HORIZONTAL; + else if(s=="TRIPLE_PANEL_VERTICAL" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_VERTICAL; + else if(s=="TRIPLE_PANEL_BOTTOM" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_BOTTOM; + else if(s=="TRIPLE_PANEL_TOP" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_TOP; + else if(s=="TRIPLE_PANEL_LEFT" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_LEFT; + else if(s=="TRIPLE_PANEL_RIGHT" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_RIGHT; + else if(s=="TRIPLE_PANEL_HORIZONTAL") return IfcWindowStyleOperationEnum::TRIPLE_PANEL_HORIZONTAL; + else if(s=="USERDEFINED" ) return IfcWindowStyleOperationEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcWindowStyleOperationEnum::NOTDEFINED; + else throw; +} +IfcWorkControlTypeEnum::IfcWorkControlTypeEnum IfcWorkControlTypeEnum::FromString(const std::string& s){ + if (s=="ACTUAL" ) return IfcWorkControlTypeEnum::ACTUAL; + else if(s=="BASELINE" ) return IfcWorkControlTypeEnum::BASELINE; + else if(s=="PLANNED" ) return IfcWorkControlTypeEnum::PLANNED; + else if(s=="USERDEFINED") return IfcWorkControlTypeEnum::USERDEFINED; + else if(s=="NOTDEFINED" ) return IfcWorkControlTypeEnum::NOTDEFINED; + else throw; +} +// Ifc2DCompositeCurve +bool Ifc2DCompositeCurve::is(Type::Enum v) { return v == Type::Ifc2DCompositeCurve || IfcCompositeCurve::is(v); } +Type::Enum Ifc2DCompositeCurve::type() { return Type::Ifc2DCompositeCurve; } +Type::Enum Ifc2DCompositeCurve::Class() { return Type::Ifc2DCompositeCurve; } +Ifc2DCompositeCurve::Ifc2DCompositeCurve(IfcAbstractEntityPtr e) { if (!is(Type::Ifc2DCompositeCurve)) throw; entity = e; } +// IfcActionRequest +IfcIdentifier IfcActionRequest::RequestID() { return *entity->getArgument(5); } +bool IfcActionRequest::is(Type::Enum v) { return v == Type::IfcActionRequest || IfcControl::is(v); } +Type::Enum IfcActionRequest::type() { return Type::IfcActionRequest; } +Type::Enum IfcActionRequest::Class() { return Type::IfcActionRequest; } +IfcActionRequest::IfcActionRequest(IfcAbstractEntityPtr e) { if (!is(Type::IfcActionRequest)) throw; entity = e; } +// IfcActor +IfcActorSelect IfcActor::TheActor() { return *entity->getArgument(5); } +IfcRelAssignsToActor::list IfcActor::IsActingUpon() { RETURN_INVERSE(IfcRelAssignsToActor) } +bool IfcActor::is(Type::Enum v) { return v == Type::IfcActor || IfcObject::is(v); } +Type::Enum IfcActor::type() { return Type::IfcActor; } +Type::Enum IfcActor::Class() { return Type::IfcActor; } +IfcActor::IfcActor(IfcAbstractEntityPtr e) { if (!is(Type::IfcActor)) throw; entity = e; } +// IfcActorRole +IfcRoleEnum::IfcRoleEnum IfcActorRole::Role() { return IfcRoleEnum::FromString(*entity->getArgument(0)); } +bool IfcActorRole::hasUserDefinedRole() { return !entity->getArgument(1)->isNull(); } +IfcLabel IfcActorRole::UserDefinedRole() { return *entity->getArgument(1); } +bool IfcActorRole::hasDescription() { return !entity->getArgument(2)->isNull(); } +IfcText IfcActorRole::Description() { return *entity->getArgument(2); } +bool IfcActorRole::is(Type::Enum v) { return v == Type::IfcActorRole; } +Type::Enum IfcActorRole::type() { return Type::IfcActorRole; } +Type::Enum IfcActorRole::Class() { return Type::IfcActorRole; } +IfcActorRole::IfcActorRole(IfcAbstractEntityPtr e) { if (!is(Type::IfcActorRole)) throw; entity = e; } +// IfcActuatorType +IfcActuatorTypeEnum::IfcActuatorTypeEnum IfcActuatorType::PredefinedType() { return IfcActuatorTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcActuatorType::is(Type::Enum v) { return v == Type::IfcActuatorType || IfcDistributionControlElementType::is(v); } +Type::Enum IfcActuatorType::type() { return Type::IfcActuatorType; } +Type::Enum IfcActuatorType::Class() { return Type::IfcActuatorType; } +IfcActuatorType::IfcActuatorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcActuatorType)) throw; entity = e; } +// IfcAddress +bool IfcAddress::hasPurpose() { return !entity->getArgument(0)->isNull(); } +IfcAddressTypeEnum::IfcAddressTypeEnum IfcAddress::Purpose() { return IfcAddressTypeEnum::FromString(*entity->getArgument(0)); } +bool IfcAddress::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcAddress::Description() { return *entity->getArgument(1); } +bool IfcAddress::hasUserDefinedPurpose() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcAddress::UserDefinedPurpose() { return *entity->getArgument(2); } +IfcPerson::list IfcAddress::OfPerson() { RETURN_INVERSE(IfcPerson) } +IfcOrganization::list IfcAddress::OfOrganization() { RETURN_INVERSE(IfcOrganization) } +bool IfcAddress::is(Type::Enum v) { return v == Type::IfcAddress; } +Type::Enum IfcAddress::type() { return Type::IfcAddress; } +Type::Enum IfcAddress::Class() { return Type::IfcAddress; } +IfcAddress::IfcAddress(IfcAbstractEntityPtr e) { if (!is(Type::IfcAddress)) throw; entity = e; } +// IfcAirTerminalBoxType +IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum IfcAirTerminalBoxType::PredefinedType() { return IfcAirTerminalBoxTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcAirTerminalBoxType::is(Type::Enum v) { return v == Type::IfcAirTerminalBoxType || IfcFlowControllerType::is(v); } +Type::Enum IfcAirTerminalBoxType::type() { return Type::IfcAirTerminalBoxType; } +Type::Enum IfcAirTerminalBoxType::Class() { return Type::IfcAirTerminalBoxType; } +IfcAirTerminalBoxType::IfcAirTerminalBoxType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAirTerminalBoxType)) throw; entity = e; } +// IfcAirTerminalType +IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum IfcAirTerminalType::PredefinedType() { return IfcAirTerminalTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcAirTerminalType::is(Type::Enum v) { return v == Type::IfcAirTerminalType || IfcFlowTerminalType::is(v); } +Type::Enum IfcAirTerminalType::type() { return Type::IfcAirTerminalType; } +Type::Enum IfcAirTerminalType::Class() { return Type::IfcAirTerminalType; } +IfcAirTerminalType::IfcAirTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAirTerminalType)) throw; entity = e; } +// IfcAirToAirHeatRecoveryType +IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum IfcAirToAirHeatRecoveryType::PredefinedType() { return IfcAirToAirHeatRecoveryTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcAirToAirHeatRecoveryType::is(Type::Enum v) { return v == Type::IfcAirToAirHeatRecoveryType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcAirToAirHeatRecoveryType::type() { return Type::IfcAirToAirHeatRecoveryType; } +Type::Enum IfcAirToAirHeatRecoveryType::Class() { return Type::IfcAirToAirHeatRecoveryType; } +IfcAirToAirHeatRecoveryType::IfcAirToAirHeatRecoveryType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAirToAirHeatRecoveryType)) throw; entity = e; } +// IfcAlarmType +IfcAlarmTypeEnum::IfcAlarmTypeEnum IfcAlarmType::PredefinedType() { return IfcAlarmTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcAlarmType::is(Type::Enum v) { return v == Type::IfcAlarmType || IfcDistributionControlElementType::is(v); } +Type::Enum IfcAlarmType::type() { return Type::IfcAlarmType; } +Type::Enum IfcAlarmType::Class() { return Type::IfcAlarmType; } +IfcAlarmType::IfcAlarmType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAlarmType)) throw; entity = e; } +// IfcAngularDimension +bool IfcAngularDimension::is(Type::Enum v) { return v == Type::IfcAngularDimension || IfcDimensionCurveDirectedCallout::is(v); } +Type::Enum IfcAngularDimension::type() { return Type::IfcAngularDimension; } +Type::Enum IfcAngularDimension::Class() { return Type::IfcAngularDimension; } +IfcAngularDimension::IfcAngularDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcAngularDimension)) throw; entity = e; } +// IfcAnnotation +IfcRelContainedInSpatialStructure::list IfcAnnotation::ContainedInStructure() { RETURN_INVERSE(IfcRelContainedInSpatialStructure) } +bool IfcAnnotation::is(Type::Enum v) { return v == Type::IfcAnnotation || IfcProduct::is(v); } +Type::Enum IfcAnnotation::type() { return Type::IfcAnnotation; } +Type::Enum IfcAnnotation::Class() { return Type::IfcAnnotation; } +IfcAnnotation::IfcAnnotation(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotation)) throw; entity = e; } +// IfcAnnotationCurveOccurrence +bool IfcAnnotationCurveOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationCurveOccurrence || IfcAnnotationOccurrence::is(v); } +Type::Enum IfcAnnotationCurveOccurrence::type() { return Type::IfcAnnotationCurveOccurrence; } +Type::Enum IfcAnnotationCurveOccurrence::Class() { return Type::IfcAnnotationCurveOccurrence; } +IfcAnnotationCurveOccurrence::IfcAnnotationCurveOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationCurveOccurrence)) throw; entity = e; } +// IfcAnnotationFillArea +SHARED_PTR IfcAnnotationFillArea::OuterBoundary() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcAnnotationFillArea::hasInnerBoundaries() { return !entity->getArgument(1)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcAnnotationFillArea::InnerBoundaries() { RETURN_AS_LIST(IfcCurve,1) } +bool IfcAnnotationFillArea::is(Type::Enum v) { return v == Type::IfcAnnotationFillArea || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcAnnotationFillArea::type() { return Type::IfcAnnotationFillArea; } +Type::Enum IfcAnnotationFillArea::Class() { return Type::IfcAnnotationFillArea; } +IfcAnnotationFillArea::IfcAnnotationFillArea(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationFillArea)) throw; entity = e; } +// IfcAnnotationFillAreaOccurrence +bool IfcAnnotationFillAreaOccurrence::hasFillStyleTarget() { return !entity->getArgument(3)->isNull(); } +SHARED_PTR IfcAnnotationFillAreaOccurrence::FillStyleTarget() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcAnnotationFillAreaOccurrence::hasGlobalOrLocal() { return !entity->getArgument(4)->isNull(); } +IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum IfcAnnotationFillAreaOccurrence::GlobalOrLocal() { return IfcGlobalOrLocalEnum::FromString(*entity->getArgument(4)); } +bool IfcAnnotationFillAreaOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationFillAreaOccurrence || IfcAnnotationOccurrence::is(v); } +Type::Enum IfcAnnotationFillAreaOccurrence::type() { return Type::IfcAnnotationFillAreaOccurrence; } +Type::Enum IfcAnnotationFillAreaOccurrence::Class() { return Type::IfcAnnotationFillAreaOccurrence; } +IfcAnnotationFillAreaOccurrence::IfcAnnotationFillAreaOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationFillAreaOccurrence)) throw; entity = e; } +// IfcAnnotationOccurrence +bool IfcAnnotationOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationOccurrence || IfcStyledItem::is(v); } +Type::Enum IfcAnnotationOccurrence::type() { return Type::IfcAnnotationOccurrence; } +Type::Enum IfcAnnotationOccurrence::Class() { return Type::IfcAnnotationOccurrence; } +IfcAnnotationOccurrence::IfcAnnotationOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationOccurrence)) throw; entity = e; } +// IfcAnnotationSurface +SHARED_PTR IfcAnnotationSurface::Item() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcAnnotationSurface::hasTextureCoordinates() { return !entity->getArgument(1)->isNull(); } +SHARED_PTR IfcAnnotationSurface::TextureCoordinates() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcAnnotationSurface::is(Type::Enum v) { return v == Type::IfcAnnotationSurface || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcAnnotationSurface::type() { return Type::IfcAnnotationSurface; } +Type::Enum IfcAnnotationSurface::Class() { return Type::IfcAnnotationSurface; } +IfcAnnotationSurface::IfcAnnotationSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationSurface)) throw; entity = e; } +// IfcAnnotationSurfaceOccurrence +bool IfcAnnotationSurfaceOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationSurfaceOccurrence || IfcAnnotationOccurrence::is(v); } +Type::Enum IfcAnnotationSurfaceOccurrence::type() { return Type::IfcAnnotationSurfaceOccurrence; } +Type::Enum IfcAnnotationSurfaceOccurrence::Class() { return Type::IfcAnnotationSurfaceOccurrence; } +IfcAnnotationSurfaceOccurrence::IfcAnnotationSurfaceOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationSurfaceOccurrence)) throw; entity = e; } +// IfcAnnotationSymbolOccurrence +bool IfcAnnotationSymbolOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationSymbolOccurrence || IfcAnnotationOccurrence::is(v); } +Type::Enum IfcAnnotationSymbolOccurrence::type() { return Type::IfcAnnotationSymbolOccurrence; } +Type::Enum IfcAnnotationSymbolOccurrence::Class() { return Type::IfcAnnotationSymbolOccurrence; } +IfcAnnotationSymbolOccurrence::IfcAnnotationSymbolOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationSymbolOccurrence)) throw; entity = e; } +// IfcAnnotationTextOccurrence +bool IfcAnnotationTextOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationTextOccurrence || IfcAnnotationOccurrence::is(v); } +Type::Enum IfcAnnotationTextOccurrence::type() { return Type::IfcAnnotationTextOccurrence; } +Type::Enum IfcAnnotationTextOccurrence::Class() { return Type::IfcAnnotationTextOccurrence; } +IfcAnnotationTextOccurrence::IfcAnnotationTextOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationTextOccurrence)) throw; entity = e; } +// IfcApplication +SHARED_PTR IfcApplication::ApplicationDeveloper() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcLabel IfcApplication::Version() { return *entity->getArgument(1); } +IfcLabel IfcApplication::ApplicationFullName() { return *entity->getArgument(2); } +IfcIdentifier IfcApplication::ApplicationIdentifier() { return *entity->getArgument(3); } +bool IfcApplication::is(Type::Enum v) { return v == Type::IfcApplication; } +Type::Enum IfcApplication::type() { return Type::IfcApplication; } +Type::Enum IfcApplication::Class() { return Type::IfcApplication; } +IfcApplication::IfcApplication(IfcAbstractEntityPtr e) { if (!is(Type::IfcApplication)) throw; entity = e; } +// IfcAppliedValue +bool IfcAppliedValue::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcAppliedValue::Name() { return *entity->getArgument(0); } +bool IfcAppliedValue::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcAppliedValue::Description() { return *entity->getArgument(1); } +bool IfcAppliedValue::hasAppliedValue() { return !entity->getArgument(2)->isNull(); } +IfcAppliedValueSelect IfcAppliedValue::AppliedValue() { return *entity->getArgument(2); } +bool IfcAppliedValue::hasUnitBasis() { return !entity->getArgument(3)->isNull(); } +SHARED_PTR IfcAppliedValue::UnitBasis() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcAppliedValue::hasApplicableDate() { return !entity->getArgument(4)->isNull(); } +IfcDateTimeSelect IfcAppliedValue::ApplicableDate() { return *entity->getArgument(4); } +bool IfcAppliedValue::hasFixedUntilDate() { return !entity->getArgument(5)->isNull(); } +IfcDateTimeSelect IfcAppliedValue::FixedUntilDate() { return *entity->getArgument(5); } +IfcReferencesValueDocument::list IfcAppliedValue::ValuesReferenced() { RETURN_INVERSE(IfcReferencesValueDocument) } +IfcAppliedValueRelationship::list IfcAppliedValue::ValueOfComponents() { RETURN_INVERSE(IfcAppliedValueRelationship) } +IfcAppliedValueRelationship::list IfcAppliedValue::IsComponentIn() { RETURN_INVERSE(IfcAppliedValueRelationship) } +bool IfcAppliedValue::is(Type::Enum v) { return v == Type::IfcAppliedValue; } +Type::Enum IfcAppliedValue::type() { return Type::IfcAppliedValue; } +Type::Enum IfcAppliedValue::Class() { return Type::IfcAppliedValue; } +IfcAppliedValue::IfcAppliedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcAppliedValue)) throw; entity = e; } +// IfcAppliedValueRelationship +SHARED_PTR IfcAppliedValueRelationship::ComponentOfTotal() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR< IfcTemplatedEntityList > IfcAppliedValueRelationship::Components() { RETURN_AS_LIST(IfcAppliedValue,1) } +IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum IfcAppliedValueRelationship::ArithmeticOperator() { return IfcArithmeticOperatorEnum::FromString(*entity->getArgument(2)); } +bool IfcAppliedValueRelationship::hasName() { return !entity->getArgument(3)->isNull(); } +IfcLabel IfcAppliedValueRelationship::Name() { return *entity->getArgument(3); } +bool IfcAppliedValueRelationship::hasDescription() { return !entity->getArgument(4)->isNull(); } +IfcText IfcAppliedValueRelationship::Description() { return *entity->getArgument(4); } +bool IfcAppliedValueRelationship::is(Type::Enum v) { return v == Type::IfcAppliedValueRelationship; } +Type::Enum IfcAppliedValueRelationship::type() { return Type::IfcAppliedValueRelationship; } +Type::Enum IfcAppliedValueRelationship::Class() { return Type::IfcAppliedValueRelationship; } +IfcAppliedValueRelationship::IfcAppliedValueRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcAppliedValueRelationship)) throw; entity = e; } +// IfcApproval +bool IfcApproval::hasDescription() { return !entity->getArgument(0)->isNull(); } +IfcText IfcApproval::Description() { return *entity->getArgument(0); } +IfcDateTimeSelect IfcApproval::ApprovalDateTime() { return *entity->getArgument(1); } +bool IfcApproval::hasApprovalStatus() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcApproval::ApprovalStatus() { return *entity->getArgument(2); } +bool IfcApproval::hasApprovalLevel() { return !entity->getArgument(3)->isNull(); } +IfcLabel IfcApproval::ApprovalLevel() { return *entity->getArgument(3); } +bool IfcApproval::hasApprovalQualifier() { return !entity->getArgument(4)->isNull(); } +IfcText IfcApproval::ApprovalQualifier() { return *entity->getArgument(4); } +IfcLabel IfcApproval::Name() { return *entity->getArgument(5); } +IfcIdentifier IfcApproval::Identifier() { return *entity->getArgument(6); } +IfcApprovalActorRelationship::list IfcApproval::Actors() { RETURN_INVERSE(IfcApprovalActorRelationship) } +IfcApprovalRelationship::list IfcApproval::IsRelatedWith() { RETURN_INVERSE(IfcApprovalRelationship) } +IfcApprovalRelationship::list IfcApproval::Relates() { RETURN_INVERSE(IfcApprovalRelationship) } +bool IfcApproval::is(Type::Enum v) { return v == Type::IfcApproval; } +Type::Enum IfcApproval::type() { return Type::IfcApproval; } +Type::Enum IfcApproval::Class() { return Type::IfcApproval; } +IfcApproval::IfcApproval(IfcAbstractEntityPtr e) { if (!is(Type::IfcApproval)) throw; entity = e; } +// IfcApprovalActorRelationship +IfcActorSelect IfcApprovalActorRelationship::Actor() { return *entity->getArgument(0); } +SHARED_PTR IfcApprovalActorRelationship::Approval() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +SHARED_PTR IfcApprovalActorRelationship::Role() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcApprovalActorRelationship::is(Type::Enum v) { return v == Type::IfcApprovalActorRelationship; } +Type::Enum IfcApprovalActorRelationship::type() { return Type::IfcApprovalActorRelationship; } +Type::Enum IfcApprovalActorRelationship::Class() { return Type::IfcApprovalActorRelationship; } +IfcApprovalActorRelationship::IfcApprovalActorRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcApprovalActorRelationship)) throw; entity = e; } +// IfcApprovalPropertyRelationship +SHARED_PTR< IfcTemplatedEntityList > IfcApprovalPropertyRelationship::ApprovedProperties() { RETURN_AS_LIST(IfcProperty,0) } +SHARED_PTR IfcApprovalPropertyRelationship::Approval() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcApprovalPropertyRelationship::is(Type::Enum v) { return v == Type::IfcApprovalPropertyRelationship; } +Type::Enum IfcApprovalPropertyRelationship::type() { return Type::IfcApprovalPropertyRelationship; } +Type::Enum IfcApprovalPropertyRelationship::Class() { return Type::IfcApprovalPropertyRelationship; } +IfcApprovalPropertyRelationship::IfcApprovalPropertyRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcApprovalPropertyRelationship)) throw; entity = e; } +// IfcApprovalRelationship +SHARED_PTR IfcApprovalRelationship::RelatedApproval() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcApprovalRelationship::RelatingApproval() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcApprovalRelationship::hasDescription() { return !entity->getArgument(2)->isNull(); } +IfcText IfcApprovalRelationship::Description() { return *entity->getArgument(2); } +IfcLabel IfcApprovalRelationship::Name() { return *entity->getArgument(3); } +bool IfcApprovalRelationship::is(Type::Enum v) { return v == Type::IfcApprovalRelationship; } +Type::Enum IfcApprovalRelationship::type() { return Type::IfcApprovalRelationship; } +Type::Enum IfcApprovalRelationship::Class() { return Type::IfcApprovalRelationship; } +IfcApprovalRelationship::IfcApprovalRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcApprovalRelationship)) throw; entity = e; } +// IfcArbitraryClosedProfileDef +SHARED_PTR IfcArbitraryClosedProfileDef::OuterCurve() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcArbitraryClosedProfileDef::is(Type::Enum v) { return v == Type::IfcArbitraryClosedProfileDef || IfcProfileDef::is(v); } +Type::Enum IfcArbitraryClosedProfileDef::type() { return Type::IfcArbitraryClosedProfileDef; } +Type::Enum IfcArbitraryClosedProfileDef::Class() { return Type::IfcArbitraryClosedProfileDef; } +IfcArbitraryClosedProfileDef::IfcArbitraryClosedProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcArbitraryClosedProfileDef)) throw; entity = e; } +// IfcArbitraryOpenProfileDef +SHARED_PTR IfcArbitraryOpenProfileDef::Curve() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcArbitraryOpenProfileDef::is(Type::Enum v) { return v == Type::IfcArbitraryOpenProfileDef || IfcProfileDef::is(v); } +Type::Enum IfcArbitraryOpenProfileDef::type() { return Type::IfcArbitraryOpenProfileDef; } +Type::Enum IfcArbitraryOpenProfileDef::Class() { return Type::IfcArbitraryOpenProfileDef; } +IfcArbitraryOpenProfileDef::IfcArbitraryOpenProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcArbitraryOpenProfileDef)) throw; entity = e; } +// IfcArbitraryProfileDefWithVoids +SHARED_PTR< IfcTemplatedEntityList > IfcArbitraryProfileDefWithVoids::InnerCurves() { RETURN_AS_LIST(IfcCurve,3) } +bool IfcArbitraryProfileDefWithVoids::is(Type::Enum v) { return v == Type::IfcArbitraryProfileDefWithVoids || IfcArbitraryClosedProfileDef::is(v); } +Type::Enum IfcArbitraryProfileDefWithVoids::type() { return Type::IfcArbitraryProfileDefWithVoids; } +Type::Enum IfcArbitraryProfileDefWithVoids::Class() { return Type::IfcArbitraryProfileDefWithVoids; } +IfcArbitraryProfileDefWithVoids::IfcArbitraryProfileDefWithVoids(IfcAbstractEntityPtr e) { if (!is(Type::IfcArbitraryProfileDefWithVoids)) throw; entity = e; } +// IfcAsset +IfcIdentifier IfcAsset::AssetID() { return *entity->getArgument(5); } +SHARED_PTR IfcAsset::OriginalValue() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +SHARED_PTR IfcAsset::CurrentValue() { return reinterpret_pointer_cast(*entity->getArgument(7)); } +SHARED_PTR IfcAsset::TotalReplacementCost() { return reinterpret_pointer_cast(*entity->getArgument(8)); } +IfcActorSelect IfcAsset::Owner() { return *entity->getArgument(9); } +IfcActorSelect IfcAsset::User() { return *entity->getArgument(10); } +SHARED_PTR IfcAsset::ResponsiblePerson() { return reinterpret_pointer_cast(*entity->getArgument(11)); } +SHARED_PTR IfcAsset::IncorporationDate() { return reinterpret_pointer_cast(*entity->getArgument(12)); } +SHARED_PTR IfcAsset::DepreciatedValue() { return reinterpret_pointer_cast(*entity->getArgument(13)); } +bool IfcAsset::is(Type::Enum v) { return v == Type::IfcAsset || IfcGroup::is(v); } +Type::Enum IfcAsset::type() { return Type::IfcAsset; } +Type::Enum IfcAsset::Class() { return Type::IfcAsset; } +IfcAsset::IfcAsset(IfcAbstractEntityPtr e) { if (!is(Type::IfcAsset)) throw; entity = e; } +// IfcAsymmetricIShapeProfileDef +IfcPositiveLengthMeasure IfcAsymmetricIShapeProfileDef::TopFlangeWidth() { return *entity->getArgument(8); } +bool IfcAsymmetricIShapeProfileDef::hasTopFlangeThickness() { return !entity->getArgument(9)->isNull(); } +IfcPositiveLengthMeasure IfcAsymmetricIShapeProfileDef::TopFlangeThickness() { return *entity->getArgument(9); } +bool IfcAsymmetricIShapeProfileDef::hasTopFlangeFilletRadius() { return !entity->getArgument(10)->isNull(); } +IfcPositiveLengthMeasure IfcAsymmetricIShapeProfileDef::TopFlangeFilletRadius() { return *entity->getArgument(10); } +bool IfcAsymmetricIShapeProfileDef::hasCentreOfGravityInY() { return !entity->getArgument(11)->isNull(); } +IfcPositiveLengthMeasure IfcAsymmetricIShapeProfileDef::CentreOfGravityInY() { return *entity->getArgument(11); } +bool IfcAsymmetricIShapeProfileDef::is(Type::Enum v) { return v == Type::IfcAsymmetricIShapeProfileDef || IfcIShapeProfileDef::is(v); } +Type::Enum IfcAsymmetricIShapeProfileDef::type() { return Type::IfcAsymmetricIShapeProfileDef; } +Type::Enum IfcAsymmetricIShapeProfileDef::Class() { return Type::IfcAsymmetricIShapeProfileDef; } +IfcAsymmetricIShapeProfileDef::IfcAsymmetricIShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcAsymmetricIShapeProfileDef)) throw; entity = e; } +// IfcAxis1Placement +bool IfcAxis1Placement::hasAxis() { return !entity->getArgument(1)->isNull(); } +SHARED_PTR IfcAxis1Placement::Axis() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcAxis1Placement::is(Type::Enum v) { return v == Type::IfcAxis1Placement || IfcPlacement::is(v); } +Type::Enum IfcAxis1Placement::type() { return Type::IfcAxis1Placement; } +Type::Enum IfcAxis1Placement::Class() { return Type::IfcAxis1Placement; } +IfcAxis1Placement::IfcAxis1Placement(IfcAbstractEntityPtr e) { if (!is(Type::IfcAxis1Placement)) throw; entity = e; } +// IfcAxis2Placement2D +bool IfcAxis2Placement2D::hasRefDirection() { return !entity->getArgument(1)->isNull(); } +SHARED_PTR IfcAxis2Placement2D::RefDirection() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcAxis2Placement2D::is(Type::Enum v) { return v == Type::IfcAxis2Placement2D || IfcPlacement::is(v); } +Type::Enum IfcAxis2Placement2D::type() { return Type::IfcAxis2Placement2D; } +Type::Enum IfcAxis2Placement2D::Class() { return Type::IfcAxis2Placement2D; } +IfcAxis2Placement2D::IfcAxis2Placement2D(IfcAbstractEntityPtr e) { if (!is(Type::IfcAxis2Placement2D)) throw; entity = e; } +// IfcAxis2Placement3D +bool IfcAxis2Placement3D::hasAxis() { return !entity->getArgument(1)->isNull(); } +SHARED_PTR IfcAxis2Placement3D::Axis() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcAxis2Placement3D::hasRefDirection() { return !entity->getArgument(2)->isNull(); } +SHARED_PTR IfcAxis2Placement3D::RefDirection() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcAxis2Placement3D::is(Type::Enum v) { return v == Type::IfcAxis2Placement3D || IfcPlacement::is(v); } +Type::Enum IfcAxis2Placement3D::type() { return Type::IfcAxis2Placement3D; } +Type::Enum IfcAxis2Placement3D::Class() { return Type::IfcAxis2Placement3D; } +IfcAxis2Placement3D::IfcAxis2Placement3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcAxis2Placement3D)) throw; entity = e; } +// IfcBSplineCurve +int IfcBSplineCurve::Degree() { return *entity->getArgument(0); } +SHARED_PTR< IfcTemplatedEntityList > IfcBSplineCurve::ControlPointsList() { RETURN_AS_LIST(IfcCartesianPoint,1) } +IfcBSplineCurveForm::IfcBSplineCurveForm IfcBSplineCurve::CurveForm() { return IfcBSplineCurveForm::FromString(*entity->getArgument(2)); } +bool IfcBSplineCurve::ClosedCurve() { return *entity->getArgument(3); } +bool IfcBSplineCurve::SelfIntersect() { return *entity->getArgument(4); } +bool IfcBSplineCurve::is(Type::Enum v) { return v == Type::IfcBSplineCurve || IfcBoundedCurve::is(v); } +Type::Enum IfcBSplineCurve::type() { return Type::IfcBSplineCurve; } +Type::Enum IfcBSplineCurve::Class() { return Type::IfcBSplineCurve; } +IfcBSplineCurve::IfcBSplineCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcBSplineCurve)) throw; entity = e; } +// IfcBeam +bool IfcBeam::is(Type::Enum v) { return v == Type::IfcBeam || IfcBuildingElement::is(v); } +Type::Enum IfcBeam::type() { return Type::IfcBeam; } +Type::Enum IfcBeam::Class() { return Type::IfcBeam; } +IfcBeam::IfcBeam(IfcAbstractEntityPtr e) { if (!is(Type::IfcBeam)) throw; entity = e; } +// IfcBeamType +IfcBeamTypeEnum::IfcBeamTypeEnum IfcBeamType::PredefinedType() { return IfcBeamTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcBeamType::is(Type::Enum v) { return v == Type::IfcBeamType || IfcBuildingElementType::is(v); } +Type::Enum IfcBeamType::type() { return Type::IfcBeamType; } +Type::Enum IfcBeamType::Class() { return Type::IfcBeamType; } +IfcBeamType::IfcBeamType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBeamType)) throw; entity = e; } +// IfcBezierCurve +bool IfcBezierCurve::is(Type::Enum v) { return v == Type::IfcBezierCurve || IfcBSplineCurve::is(v); } +Type::Enum IfcBezierCurve::type() { return Type::IfcBezierCurve; } +Type::Enum IfcBezierCurve::Class() { return Type::IfcBezierCurve; } +IfcBezierCurve::IfcBezierCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcBezierCurve)) throw; entity = e; } +// IfcBlobTexture +IfcIdentifier IfcBlobTexture::RasterFormat() { return *entity->getArgument(4); } +bool IfcBlobTexture::RasterCode() { return *entity->getArgument(5); } +bool IfcBlobTexture::is(Type::Enum v) { return v == Type::IfcBlobTexture || IfcSurfaceTexture::is(v); } +Type::Enum IfcBlobTexture::type() { return Type::IfcBlobTexture; } +Type::Enum IfcBlobTexture::Class() { return Type::IfcBlobTexture; } +IfcBlobTexture::IfcBlobTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcBlobTexture)) throw; entity = e; } +// IfcBlock +IfcPositiveLengthMeasure IfcBlock::XLength() { return *entity->getArgument(1); } +IfcPositiveLengthMeasure IfcBlock::YLength() { return *entity->getArgument(2); } +IfcPositiveLengthMeasure IfcBlock::ZLength() { return *entity->getArgument(3); } +bool IfcBlock::is(Type::Enum v) { return v == Type::IfcBlock || IfcCsgPrimitive3D::is(v); } +Type::Enum IfcBlock::type() { return Type::IfcBlock; } +Type::Enum IfcBlock::Class() { return Type::IfcBlock; } +IfcBlock::IfcBlock(IfcAbstractEntityPtr e) { if (!is(Type::IfcBlock)) throw; entity = e; } +// IfcBoilerType +IfcBoilerTypeEnum::IfcBoilerTypeEnum IfcBoilerType::PredefinedType() { return IfcBoilerTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcBoilerType::is(Type::Enum v) { return v == Type::IfcBoilerType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcBoilerType::type() { return Type::IfcBoilerType; } +Type::Enum IfcBoilerType::Class() { return Type::IfcBoilerType; } +IfcBoilerType::IfcBoilerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoilerType)) throw; entity = e; } +// IfcBooleanClippingResult +bool IfcBooleanClippingResult::is(Type::Enum v) { return v == Type::IfcBooleanClippingResult || IfcBooleanResult::is(v); } +Type::Enum IfcBooleanClippingResult::type() { return Type::IfcBooleanClippingResult; } +Type::Enum IfcBooleanClippingResult::Class() { return Type::IfcBooleanClippingResult; } +IfcBooleanClippingResult::IfcBooleanClippingResult(IfcAbstractEntityPtr e) { if (!is(Type::IfcBooleanClippingResult)) throw; entity = e; } +// IfcBooleanResult +IfcBooleanOperator::IfcBooleanOperator IfcBooleanResult::Operator() { return IfcBooleanOperator::FromString(*entity->getArgument(0)); } +IfcBooleanOperand IfcBooleanResult::FirstOperand() { return *entity->getArgument(1); } +IfcBooleanOperand IfcBooleanResult::SecondOperand() { return *entity->getArgument(2); } +bool IfcBooleanResult::is(Type::Enum v) { return v == Type::IfcBooleanResult || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcBooleanResult::type() { return Type::IfcBooleanResult; } +Type::Enum IfcBooleanResult::Class() { return Type::IfcBooleanResult; } +IfcBooleanResult::IfcBooleanResult(IfcAbstractEntityPtr e) { if (!is(Type::IfcBooleanResult)) throw; entity = e; } +// IfcBoundaryCondition +bool IfcBoundaryCondition::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcBoundaryCondition::Name() { return *entity->getArgument(0); } +bool IfcBoundaryCondition::is(Type::Enum v) { return v == Type::IfcBoundaryCondition; } +Type::Enum IfcBoundaryCondition::type() { return Type::IfcBoundaryCondition; } +Type::Enum IfcBoundaryCondition::Class() { return Type::IfcBoundaryCondition; } +IfcBoundaryCondition::IfcBoundaryCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryCondition)) throw; entity = e; } +// IfcBoundaryEdgeCondition +bool IfcBoundaryEdgeCondition::hasLinearStiffnessByLengthX() { return !entity->getArgument(1)->isNull(); } +IfcModulusOfLinearSubgradeReactionMeasure IfcBoundaryEdgeCondition::LinearStiffnessByLengthX() { return *entity->getArgument(1); } +bool IfcBoundaryEdgeCondition::hasLinearStiffnessByLengthY() { return !entity->getArgument(2)->isNull(); } +IfcModulusOfLinearSubgradeReactionMeasure IfcBoundaryEdgeCondition::LinearStiffnessByLengthY() { return *entity->getArgument(2); } +bool IfcBoundaryEdgeCondition::hasLinearStiffnessByLengthZ() { return !entity->getArgument(3)->isNull(); } +IfcModulusOfLinearSubgradeReactionMeasure IfcBoundaryEdgeCondition::LinearStiffnessByLengthZ() { return *entity->getArgument(3); } +bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthX() { return !entity->getArgument(4)->isNull(); } +IfcModulusOfRotationalSubgradeReactionMeasure IfcBoundaryEdgeCondition::RotationalStiffnessByLengthX() { return *entity->getArgument(4); } +bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthY() { return !entity->getArgument(5)->isNull(); } +IfcModulusOfRotationalSubgradeReactionMeasure IfcBoundaryEdgeCondition::RotationalStiffnessByLengthY() { return *entity->getArgument(5); } +bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthZ() { return !entity->getArgument(6)->isNull(); } +IfcModulusOfRotationalSubgradeReactionMeasure IfcBoundaryEdgeCondition::RotationalStiffnessByLengthZ() { return *entity->getArgument(6); } +bool IfcBoundaryEdgeCondition::is(Type::Enum v) { return v == Type::IfcBoundaryEdgeCondition || IfcBoundaryCondition::is(v); } +Type::Enum IfcBoundaryEdgeCondition::type() { return Type::IfcBoundaryEdgeCondition; } +Type::Enum IfcBoundaryEdgeCondition::Class() { return Type::IfcBoundaryEdgeCondition; } +IfcBoundaryEdgeCondition::IfcBoundaryEdgeCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryEdgeCondition)) throw; entity = e; } +// IfcBoundaryFaceCondition +bool IfcBoundaryFaceCondition::hasLinearStiffnessByAreaX() { return !entity->getArgument(1)->isNull(); } +IfcModulusOfSubgradeReactionMeasure IfcBoundaryFaceCondition::LinearStiffnessByAreaX() { return *entity->getArgument(1); } +bool IfcBoundaryFaceCondition::hasLinearStiffnessByAreaY() { return !entity->getArgument(2)->isNull(); } +IfcModulusOfSubgradeReactionMeasure IfcBoundaryFaceCondition::LinearStiffnessByAreaY() { return *entity->getArgument(2); } +bool IfcBoundaryFaceCondition::hasLinearStiffnessByAreaZ() { return !entity->getArgument(3)->isNull(); } +IfcModulusOfSubgradeReactionMeasure IfcBoundaryFaceCondition::LinearStiffnessByAreaZ() { return *entity->getArgument(3); } +bool IfcBoundaryFaceCondition::is(Type::Enum v) { return v == Type::IfcBoundaryFaceCondition || IfcBoundaryCondition::is(v); } +Type::Enum IfcBoundaryFaceCondition::type() { return Type::IfcBoundaryFaceCondition; } +Type::Enum IfcBoundaryFaceCondition::Class() { return Type::IfcBoundaryFaceCondition; } +IfcBoundaryFaceCondition::IfcBoundaryFaceCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryFaceCondition)) throw; entity = e; } +// IfcBoundaryNodeCondition +bool IfcBoundaryNodeCondition::hasLinearStiffnessX() { return !entity->getArgument(1)->isNull(); } +IfcLinearStiffnessMeasure IfcBoundaryNodeCondition::LinearStiffnessX() { return *entity->getArgument(1); } +bool IfcBoundaryNodeCondition::hasLinearStiffnessY() { return !entity->getArgument(2)->isNull(); } +IfcLinearStiffnessMeasure IfcBoundaryNodeCondition::LinearStiffnessY() { return *entity->getArgument(2); } +bool IfcBoundaryNodeCondition::hasLinearStiffnessZ() { return !entity->getArgument(3)->isNull(); } +IfcLinearStiffnessMeasure IfcBoundaryNodeCondition::LinearStiffnessZ() { return *entity->getArgument(3); } +bool IfcBoundaryNodeCondition::hasRotationalStiffnessX() { return !entity->getArgument(4)->isNull(); } +IfcRotationalStiffnessMeasure IfcBoundaryNodeCondition::RotationalStiffnessX() { return *entity->getArgument(4); } +bool IfcBoundaryNodeCondition::hasRotationalStiffnessY() { return !entity->getArgument(5)->isNull(); } +IfcRotationalStiffnessMeasure IfcBoundaryNodeCondition::RotationalStiffnessY() { return *entity->getArgument(5); } +bool IfcBoundaryNodeCondition::hasRotationalStiffnessZ() { return !entity->getArgument(6)->isNull(); } +IfcRotationalStiffnessMeasure IfcBoundaryNodeCondition::RotationalStiffnessZ() { return *entity->getArgument(6); } +bool IfcBoundaryNodeCondition::is(Type::Enum v) { return v == Type::IfcBoundaryNodeCondition || IfcBoundaryCondition::is(v); } +Type::Enum IfcBoundaryNodeCondition::type() { return Type::IfcBoundaryNodeCondition; } +Type::Enum IfcBoundaryNodeCondition::Class() { return Type::IfcBoundaryNodeCondition; } +IfcBoundaryNodeCondition::IfcBoundaryNodeCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryNodeCondition)) throw; entity = e; } +// IfcBoundaryNodeConditionWarping +bool IfcBoundaryNodeConditionWarping::hasWarpingStiffness() { return !entity->getArgument(7)->isNull(); } +IfcWarpingMomentMeasure IfcBoundaryNodeConditionWarping::WarpingStiffness() { return *entity->getArgument(7); } +bool IfcBoundaryNodeConditionWarping::is(Type::Enum v) { return v == Type::IfcBoundaryNodeConditionWarping || IfcBoundaryNodeCondition::is(v); } +Type::Enum IfcBoundaryNodeConditionWarping::type() { return Type::IfcBoundaryNodeConditionWarping; } +Type::Enum IfcBoundaryNodeConditionWarping::Class() { return Type::IfcBoundaryNodeConditionWarping; } +IfcBoundaryNodeConditionWarping::IfcBoundaryNodeConditionWarping(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryNodeConditionWarping)) throw; entity = e; } +// IfcBoundedCurve +bool IfcBoundedCurve::is(Type::Enum v) { return v == Type::IfcBoundedCurve || IfcCurve::is(v); } +Type::Enum IfcBoundedCurve::type() { return Type::IfcBoundedCurve; } +Type::Enum IfcBoundedCurve::Class() { return Type::IfcBoundedCurve; } +IfcBoundedCurve::IfcBoundedCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundedCurve)) throw; entity = e; } +// IfcBoundedSurface +bool IfcBoundedSurface::is(Type::Enum v) { return v == Type::IfcBoundedSurface || IfcSurface::is(v); } +Type::Enum IfcBoundedSurface::type() { return Type::IfcBoundedSurface; } +Type::Enum IfcBoundedSurface::Class() { return Type::IfcBoundedSurface; } +IfcBoundedSurface::IfcBoundedSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundedSurface)) throw; entity = e; } +// IfcBoundingBox +SHARED_PTR IfcBoundingBox::Corner() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcPositiveLengthMeasure IfcBoundingBox::XDim() { return *entity->getArgument(1); } +IfcPositiveLengthMeasure IfcBoundingBox::YDim() { return *entity->getArgument(2); } +IfcPositiveLengthMeasure IfcBoundingBox::ZDim() { return *entity->getArgument(3); } +bool IfcBoundingBox::is(Type::Enum v) { return v == Type::IfcBoundingBox || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcBoundingBox::type() { return Type::IfcBoundingBox; } +Type::Enum IfcBoundingBox::Class() { return Type::IfcBoundingBox; } +IfcBoundingBox::IfcBoundingBox(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundingBox)) throw; entity = e; } +// IfcBoxedHalfSpace +SHARED_PTR IfcBoxedHalfSpace::Enclosure() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcBoxedHalfSpace::is(Type::Enum v) { return v == Type::IfcBoxedHalfSpace || IfcHalfSpaceSolid::is(v); } +Type::Enum IfcBoxedHalfSpace::type() { return Type::IfcBoxedHalfSpace; } +Type::Enum IfcBoxedHalfSpace::Class() { return Type::IfcBoxedHalfSpace; } +IfcBoxedHalfSpace::IfcBoxedHalfSpace(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoxedHalfSpace)) throw; entity = e; } +// IfcBuilding +bool IfcBuilding::hasElevationOfRefHeight() { return !entity->getArgument(9)->isNull(); } +IfcLengthMeasure IfcBuilding::ElevationOfRefHeight() { return *entity->getArgument(9); } +bool IfcBuilding::hasElevationOfTerrain() { return !entity->getArgument(10)->isNull(); } +IfcLengthMeasure IfcBuilding::ElevationOfTerrain() { return *entity->getArgument(10); } +bool IfcBuilding::hasBuildingAddress() { return !entity->getArgument(11)->isNull(); } +SHARED_PTR IfcBuilding::BuildingAddress() { return reinterpret_pointer_cast(*entity->getArgument(11)); } +bool IfcBuilding::is(Type::Enum v) { return v == Type::IfcBuilding || IfcSpatialStructureElement::is(v); } +Type::Enum IfcBuilding::type() { return Type::IfcBuilding; } +Type::Enum IfcBuilding::Class() { return Type::IfcBuilding; } +IfcBuilding::IfcBuilding(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuilding)) throw; entity = e; } +// IfcBuildingElement +bool IfcBuildingElement::is(Type::Enum v) { return v == Type::IfcBuildingElement || IfcElement::is(v); } +Type::Enum IfcBuildingElement::type() { return Type::IfcBuildingElement; } +Type::Enum IfcBuildingElement::Class() { return Type::IfcBuildingElement; } +IfcBuildingElement::IfcBuildingElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElement)) throw; entity = e; } +// IfcBuildingElementComponent +bool IfcBuildingElementComponent::is(Type::Enum v) { return v == Type::IfcBuildingElementComponent || IfcBuildingElement::is(v); } +Type::Enum IfcBuildingElementComponent::type() { return Type::IfcBuildingElementComponent; } +Type::Enum IfcBuildingElementComponent::Class() { return Type::IfcBuildingElementComponent; } +IfcBuildingElementComponent::IfcBuildingElementComponent(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementComponent)) throw; entity = e; } +// IfcBuildingElementPart +bool IfcBuildingElementPart::is(Type::Enum v) { return v == Type::IfcBuildingElementPart || IfcBuildingElementComponent::is(v); } +Type::Enum IfcBuildingElementPart::type() { return Type::IfcBuildingElementPart; } +Type::Enum IfcBuildingElementPart::Class() { return Type::IfcBuildingElementPart; } +IfcBuildingElementPart::IfcBuildingElementPart(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementPart)) throw; entity = e; } +// IfcBuildingElementProxy +bool IfcBuildingElementProxy::hasCompositionType() { return !entity->getArgument(8)->isNull(); } +IfcElementCompositionEnum::IfcElementCompositionEnum IfcBuildingElementProxy::CompositionType() { return IfcElementCompositionEnum::FromString(*entity->getArgument(8)); } +bool IfcBuildingElementProxy::is(Type::Enum v) { return v == Type::IfcBuildingElementProxy || IfcBuildingElement::is(v); } +Type::Enum IfcBuildingElementProxy::type() { return Type::IfcBuildingElementProxy; } +Type::Enum IfcBuildingElementProxy::Class() { return Type::IfcBuildingElementProxy; } +IfcBuildingElementProxy::IfcBuildingElementProxy(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementProxy)) throw; entity = e; } +// IfcBuildingElementProxyType +IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum IfcBuildingElementProxyType::PredefinedType() { return IfcBuildingElementProxyTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcBuildingElementProxyType::is(Type::Enum v) { return v == Type::IfcBuildingElementProxyType || IfcBuildingElementType::is(v); } +Type::Enum IfcBuildingElementProxyType::type() { return Type::IfcBuildingElementProxyType; } +Type::Enum IfcBuildingElementProxyType::Class() { return Type::IfcBuildingElementProxyType; } +IfcBuildingElementProxyType::IfcBuildingElementProxyType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementProxyType)) throw; entity = e; } +// IfcBuildingElementType +bool IfcBuildingElementType::is(Type::Enum v) { return v == Type::IfcBuildingElementType || IfcElementType::is(v); } +Type::Enum IfcBuildingElementType::type() { return Type::IfcBuildingElementType; } +Type::Enum IfcBuildingElementType::Class() { return Type::IfcBuildingElementType; } +IfcBuildingElementType::IfcBuildingElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementType)) throw; entity = e; } +// IfcBuildingStorey +bool IfcBuildingStorey::hasElevation() { return !entity->getArgument(9)->isNull(); } +IfcLengthMeasure IfcBuildingStorey::Elevation() { return *entity->getArgument(9); } +bool IfcBuildingStorey::is(Type::Enum v) { return v == Type::IfcBuildingStorey || IfcSpatialStructureElement::is(v); } +Type::Enum IfcBuildingStorey::type() { return Type::IfcBuildingStorey; } +Type::Enum IfcBuildingStorey::Class() { return Type::IfcBuildingStorey; } +IfcBuildingStorey::IfcBuildingStorey(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingStorey)) throw; entity = e; } +// IfcCShapeProfileDef +IfcPositiveLengthMeasure IfcCShapeProfileDef::Depth() { return *entity->getArgument(3); } +IfcPositiveLengthMeasure IfcCShapeProfileDef::Width() { return *entity->getArgument(4); } +IfcPositiveLengthMeasure IfcCShapeProfileDef::WallThickness() { return *entity->getArgument(5); } +IfcPositiveLengthMeasure IfcCShapeProfileDef::Girth() { return *entity->getArgument(6); } +bool IfcCShapeProfileDef::hasInternalFilletRadius() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcCShapeProfileDef::InternalFilletRadius() { return *entity->getArgument(7); } +bool IfcCShapeProfileDef::hasCentreOfGravityInX() { return !entity->getArgument(8)->isNull(); } +IfcPositiveLengthMeasure IfcCShapeProfileDef::CentreOfGravityInX() { return *entity->getArgument(8); } +bool IfcCShapeProfileDef::is(Type::Enum v) { return v == Type::IfcCShapeProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcCShapeProfileDef::type() { return Type::IfcCShapeProfileDef; } +Type::Enum IfcCShapeProfileDef::Class() { return Type::IfcCShapeProfileDef; } +IfcCShapeProfileDef::IfcCShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCShapeProfileDef)) throw; entity = e; } +// IfcCableCarrierFittingType +IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum IfcCableCarrierFittingType::PredefinedType() { return IfcCableCarrierFittingTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcCableCarrierFittingType::is(Type::Enum v) { return v == Type::IfcCableCarrierFittingType || IfcFlowFittingType::is(v); } +Type::Enum IfcCableCarrierFittingType::type() { return Type::IfcCableCarrierFittingType; } +Type::Enum IfcCableCarrierFittingType::Class() { return Type::IfcCableCarrierFittingType; } +IfcCableCarrierFittingType::IfcCableCarrierFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCableCarrierFittingType)) throw; entity = e; } +// IfcCableCarrierSegmentType +IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum IfcCableCarrierSegmentType::PredefinedType() { return IfcCableCarrierSegmentTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcCableCarrierSegmentType::is(Type::Enum v) { return v == Type::IfcCableCarrierSegmentType || IfcFlowSegmentType::is(v); } +Type::Enum IfcCableCarrierSegmentType::type() { return Type::IfcCableCarrierSegmentType; } +Type::Enum IfcCableCarrierSegmentType::Class() { return Type::IfcCableCarrierSegmentType; } +IfcCableCarrierSegmentType::IfcCableCarrierSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCableCarrierSegmentType)) throw; entity = e; } +// IfcCableSegmentType +IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum IfcCableSegmentType::PredefinedType() { return IfcCableSegmentTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcCableSegmentType::is(Type::Enum v) { return v == Type::IfcCableSegmentType || IfcFlowSegmentType::is(v); } +Type::Enum IfcCableSegmentType::type() { return Type::IfcCableSegmentType; } +Type::Enum IfcCableSegmentType::Class() { return Type::IfcCableSegmentType; } +IfcCableSegmentType::IfcCableSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCableSegmentType)) throw; entity = e; } +// IfcCalendarDate +IfcDayInMonthNumber IfcCalendarDate::DayComponent() { return *entity->getArgument(0); } +IfcMonthInYearNumber IfcCalendarDate::MonthComponent() { return *entity->getArgument(1); } +IfcYearNumber IfcCalendarDate::YearComponent() { return *entity->getArgument(2); } +bool IfcCalendarDate::is(Type::Enum v) { return v == Type::IfcCalendarDate; } +Type::Enum IfcCalendarDate::type() { return Type::IfcCalendarDate; } +Type::Enum IfcCalendarDate::Class() { return Type::IfcCalendarDate; } +IfcCalendarDate::IfcCalendarDate(IfcAbstractEntityPtr e) { if (!is(Type::IfcCalendarDate)) throw; entity = e; } +// IfcCartesianPoint +std::vector IfcCartesianPoint::Coordinates() { return *entity->getArgument(0); } +bool IfcCartesianPoint::is(Type::Enum v) { return v == Type::IfcCartesianPoint || IfcPoint::is(v); } +Type::Enum IfcCartesianPoint::type() { return Type::IfcCartesianPoint; } +Type::Enum IfcCartesianPoint::Class() { return Type::IfcCartesianPoint; } +IfcCartesianPoint::IfcCartesianPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianPoint)) throw; entity = e; } +// IfcCartesianTransformationOperator +bool IfcCartesianTransformationOperator::hasAxis1() { return !entity->getArgument(0)->isNull(); } +SHARED_PTR IfcCartesianTransformationOperator::Axis1() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcCartesianTransformationOperator::hasAxis2() { return !entity->getArgument(1)->isNull(); } +SHARED_PTR IfcCartesianTransformationOperator::Axis2() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +SHARED_PTR IfcCartesianTransformationOperator::LocalOrigin() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcCartesianTransformationOperator::hasScale() { return !entity->getArgument(3)->isNull(); } +float IfcCartesianTransformationOperator::Scale() { return *entity->getArgument(3); } +bool IfcCartesianTransformationOperator::is(Type::Enum v) { return v == Type::IfcCartesianTransformationOperator || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcCartesianTransformationOperator::type() { return Type::IfcCartesianTransformationOperator; } +Type::Enum IfcCartesianTransformationOperator::Class() { return Type::IfcCartesianTransformationOperator; } +IfcCartesianTransformationOperator::IfcCartesianTransformationOperator(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator)) throw; entity = e; } +// IfcCartesianTransformationOperator2D +bool IfcCartesianTransformationOperator2D::is(Type::Enum v) { return v == Type::IfcCartesianTransformationOperator2D || IfcCartesianTransformationOperator::is(v); } +Type::Enum IfcCartesianTransformationOperator2D::type() { return Type::IfcCartesianTransformationOperator2D; } +Type::Enum IfcCartesianTransformationOperator2D::Class() { return Type::IfcCartesianTransformationOperator2D; } +IfcCartesianTransformationOperator2D::IfcCartesianTransformationOperator2D(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator2D)) throw; entity = e; } +// IfcCartesianTransformationOperator2DnonUniform +bool IfcCartesianTransformationOperator2DnonUniform::hasScale2() { return !entity->getArgument(4)->isNull(); } +float IfcCartesianTransformationOperator2DnonUniform::Scale2() { return *entity->getArgument(4); } +bool IfcCartesianTransformationOperator2DnonUniform::is(Type::Enum v) { return v == Type::IfcCartesianTransformationOperator2DnonUniform || IfcCartesianTransformationOperator2D::is(v); } +Type::Enum IfcCartesianTransformationOperator2DnonUniform::type() { return Type::IfcCartesianTransformationOperator2DnonUniform; } +Type::Enum IfcCartesianTransformationOperator2DnonUniform::Class() { return Type::IfcCartesianTransformationOperator2DnonUniform; } +IfcCartesianTransformationOperator2DnonUniform::IfcCartesianTransformationOperator2DnonUniform(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator2DnonUniform)) throw; entity = e; } +// IfcCartesianTransformationOperator3D +bool IfcCartesianTransformationOperator3D::hasAxis3() { return !entity->getArgument(4)->isNull(); } +SHARED_PTR IfcCartesianTransformationOperator3D::Axis3() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +bool IfcCartesianTransformationOperator3D::is(Type::Enum v) { return v == Type::IfcCartesianTransformationOperator3D || IfcCartesianTransformationOperator::is(v); } +Type::Enum IfcCartesianTransformationOperator3D::type() { return Type::IfcCartesianTransformationOperator3D; } +Type::Enum IfcCartesianTransformationOperator3D::Class() { return Type::IfcCartesianTransformationOperator3D; } +IfcCartesianTransformationOperator3D::IfcCartesianTransformationOperator3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator3D)) throw; entity = e; } +// IfcCartesianTransformationOperator3DnonUniform +bool IfcCartesianTransformationOperator3DnonUniform::hasScale2() { return !entity->getArgument(5)->isNull(); } +float IfcCartesianTransformationOperator3DnonUniform::Scale2() { return *entity->getArgument(5); } +bool IfcCartesianTransformationOperator3DnonUniform::hasScale3() { return !entity->getArgument(6)->isNull(); } +float IfcCartesianTransformationOperator3DnonUniform::Scale3() { return *entity->getArgument(6); } +bool IfcCartesianTransformationOperator3DnonUniform::is(Type::Enum v) { return v == Type::IfcCartesianTransformationOperator3DnonUniform || IfcCartesianTransformationOperator3D::is(v); } +Type::Enum IfcCartesianTransformationOperator3DnonUniform::type() { return Type::IfcCartesianTransformationOperator3DnonUniform; } +Type::Enum IfcCartesianTransformationOperator3DnonUniform::Class() { return Type::IfcCartesianTransformationOperator3DnonUniform; } +IfcCartesianTransformationOperator3DnonUniform::IfcCartesianTransformationOperator3DnonUniform(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator3DnonUniform)) throw; entity = e; } +// IfcCenterLineProfileDef +IfcPositiveLengthMeasure IfcCenterLineProfileDef::Thickness() { return *entity->getArgument(3); } +bool IfcCenterLineProfileDef::is(Type::Enum v) { return v == Type::IfcCenterLineProfileDef || IfcArbitraryOpenProfileDef::is(v); } +Type::Enum IfcCenterLineProfileDef::type() { return Type::IfcCenterLineProfileDef; } +Type::Enum IfcCenterLineProfileDef::Class() { return Type::IfcCenterLineProfileDef; } +IfcCenterLineProfileDef::IfcCenterLineProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCenterLineProfileDef)) throw; entity = e; } +// IfcChamferEdgeFeature +bool IfcChamferEdgeFeature::hasWidth() { return !entity->getArgument(9)->isNull(); } +IfcPositiveLengthMeasure IfcChamferEdgeFeature::Width() { return *entity->getArgument(9); } +bool IfcChamferEdgeFeature::hasHeight() { return !entity->getArgument(10)->isNull(); } +IfcPositiveLengthMeasure IfcChamferEdgeFeature::Height() { return *entity->getArgument(10); } +bool IfcChamferEdgeFeature::is(Type::Enum v) { return v == Type::IfcChamferEdgeFeature || IfcEdgeFeature::is(v); } +Type::Enum IfcChamferEdgeFeature::type() { return Type::IfcChamferEdgeFeature; } +Type::Enum IfcChamferEdgeFeature::Class() { return Type::IfcChamferEdgeFeature; } +IfcChamferEdgeFeature::IfcChamferEdgeFeature(IfcAbstractEntityPtr e) { if (!is(Type::IfcChamferEdgeFeature)) throw; entity = e; } +// IfcChillerType +IfcChillerTypeEnum::IfcChillerTypeEnum IfcChillerType::PredefinedType() { return IfcChillerTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcChillerType::is(Type::Enum v) { return v == Type::IfcChillerType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcChillerType::type() { return Type::IfcChillerType; } +Type::Enum IfcChillerType::Class() { return Type::IfcChillerType; } +IfcChillerType::IfcChillerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcChillerType)) throw; entity = e; } +// IfcCircle +IfcPositiveLengthMeasure IfcCircle::Radius() { return *entity->getArgument(1); } +bool IfcCircle::is(Type::Enum v) { return v == Type::IfcCircle || IfcConic::is(v); } +Type::Enum IfcCircle::type() { return Type::IfcCircle; } +Type::Enum IfcCircle::Class() { return Type::IfcCircle; } +IfcCircle::IfcCircle(IfcAbstractEntityPtr e) { if (!is(Type::IfcCircle)) throw; entity = e; } +// IfcCircleHollowProfileDef +IfcPositiveLengthMeasure IfcCircleHollowProfileDef::WallThickness() { return *entity->getArgument(4); } +bool IfcCircleHollowProfileDef::is(Type::Enum v) { return v == Type::IfcCircleHollowProfileDef || IfcCircleProfileDef::is(v); } +Type::Enum IfcCircleHollowProfileDef::type() { return Type::IfcCircleHollowProfileDef; } +Type::Enum IfcCircleHollowProfileDef::Class() { return Type::IfcCircleHollowProfileDef; } +IfcCircleHollowProfileDef::IfcCircleHollowProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCircleHollowProfileDef)) throw; entity = e; } +// IfcCircleProfileDef +IfcPositiveLengthMeasure IfcCircleProfileDef::Radius() { return *entity->getArgument(3); } +bool IfcCircleProfileDef::is(Type::Enum v) { return v == Type::IfcCircleProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcCircleProfileDef::type() { return Type::IfcCircleProfileDef; } +Type::Enum IfcCircleProfileDef::Class() { return Type::IfcCircleProfileDef; } +IfcCircleProfileDef::IfcCircleProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCircleProfileDef)) throw; entity = e; } +// IfcClassification +IfcLabel IfcClassification::Source() { return *entity->getArgument(0); } +IfcLabel IfcClassification::Edition() { return *entity->getArgument(1); } +bool IfcClassification::hasEditionDate() { return !entity->getArgument(2)->isNull(); } +SHARED_PTR IfcClassification::EditionDate() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +IfcLabel IfcClassification::Name() { return *entity->getArgument(3); } +IfcClassificationItem::list IfcClassification::Contains() { RETURN_INVERSE(IfcClassificationItem) } +bool IfcClassification::is(Type::Enum v) { return v == Type::IfcClassification; } +Type::Enum IfcClassification::type() { return Type::IfcClassification; } +Type::Enum IfcClassification::Class() { return Type::IfcClassification; } +IfcClassification::IfcClassification(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassification)) throw; entity = e; } +// IfcClassificationItem +SHARED_PTR IfcClassificationItem::Notation() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcClassificationItem::hasItemOf() { return !entity->getArgument(1)->isNull(); } +SHARED_PTR IfcClassificationItem::ItemOf() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +IfcLabel IfcClassificationItem::Title() { return *entity->getArgument(2); } +IfcClassificationItemRelationship::list IfcClassificationItem::IsClassifiedItemIn() { RETURN_INVERSE(IfcClassificationItemRelationship) } +IfcClassificationItemRelationship::list IfcClassificationItem::IsClassifyingItemIn() { RETURN_INVERSE(IfcClassificationItemRelationship) } +bool IfcClassificationItem::is(Type::Enum v) { return v == Type::IfcClassificationItem; } +Type::Enum IfcClassificationItem::type() { return Type::IfcClassificationItem; } +Type::Enum IfcClassificationItem::Class() { return Type::IfcClassificationItem; } +IfcClassificationItem::IfcClassificationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationItem)) throw; entity = e; } +// IfcClassificationItemRelationship +SHARED_PTR IfcClassificationItemRelationship::RelatingItem() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR< IfcTemplatedEntityList > IfcClassificationItemRelationship::RelatedItems() { RETURN_AS_LIST(IfcClassificationItem,1) } +bool IfcClassificationItemRelationship::is(Type::Enum v) { return v == Type::IfcClassificationItemRelationship; } +Type::Enum IfcClassificationItemRelationship::type() { return Type::IfcClassificationItemRelationship; } +Type::Enum IfcClassificationItemRelationship::Class() { return Type::IfcClassificationItemRelationship; } +IfcClassificationItemRelationship::IfcClassificationItemRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationItemRelationship)) throw; entity = e; } +// IfcClassificationNotation +SHARED_PTR< IfcTemplatedEntityList > IfcClassificationNotation::NotationFacets() { RETURN_AS_LIST(IfcClassificationNotationFacet,0) } +bool IfcClassificationNotation::is(Type::Enum v) { return v == Type::IfcClassificationNotation; } +Type::Enum IfcClassificationNotation::type() { return Type::IfcClassificationNotation; } +Type::Enum IfcClassificationNotation::Class() { return Type::IfcClassificationNotation; } +IfcClassificationNotation::IfcClassificationNotation(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationNotation)) throw; entity = e; } +// IfcClassificationNotationFacet +IfcLabel IfcClassificationNotationFacet::NotationValue() { return *entity->getArgument(0); } +bool IfcClassificationNotationFacet::is(Type::Enum v) { return v == Type::IfcClassificationNotationFacet; } +Type::Enum IfcClassificationNotationFacet::type() { return Type::IfcClassificationNotationFacet; } +Type::Enum IfcClassificationNotationFacet::Class() { return Type::IfcClassificationNotationFacet; } +IfcClassificationNotationFacet::IfcClassificationNotationFacet(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationNotationFacet)) throw; entity = e; } +// IfcClassificationReference +bool IfcClassificationReference::hasReferencedSource() { return !entity->getArgument(3)->isNull(); } +SHARED_PTR IfcClassificationReference::ReferencedSource() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcClassificationReference::is(Type::Enum v) { return v == Type::IfcClassificationReference || IfcExternalReference::is(v); } +Type::Enum IfcClassificationReference::type() { return Type::IfcClassificationReference; } +Type::Enum IfcClassificationReference::Class() { return Type::IfcClassificationReference; } +IfcClassificationReference::IfcClassificationReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationReference)) throw; entity = e; } +// IfcClosedShell +bool IfcClosedShell::is(Type::Enum v) { return v == Type::IfcClosedShell || IfcConnectedFaceSet::is(v); } +Type::Enum IfcClosedShell::type() { return Type::IfcClosedShell; } +Type::Enum IfcClosedShell::Class() { return Type::IfcClosedShell; } +IfcClosedShell::IfcClosedShell(IfcAbstractEntityPtr e) { if (!is(Type::IfcClosedShell)) throw; entity = e; } +// IfcCoilType +IfcCoilTypeEnum::IfcCoilTypeEnum IfcCoilType::PredefinedType() { return IfcCoilTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcCoilType::is(Type::Enum v) { return v == Type::IfcCoilType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcCoilType::type() { return Type::IfcCoilType; } +Type::Enum IfcCoilType::Class() { return Type::IfcCoilType; } +IfcCoilType::IfcCoilType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoilType)) throw; entity = e; } +// IfcColourRgb +IfcNormalisedRatioMeasure IfcColourRgb::Red() { return *entity->getArgument(1); } +IfcNormalisedRatioMeasure IfcColourRgb::Green() { return *entity->getArgument(2); } +IfcNormalisedRatioMeasure IfcColourRgb::Blue() { return *entity->getArgument(3); } +bool IfcColourRgb::is(Type::Enum v) { return v == Type::IfcColourRgb || IfcColourSpecification::is(v); } +Type::Enum IfcColourRgb::type() { return Type::IfcColourRgb; } +Type::Enum IfcColourRgb::Class() { return Type::IfcColourRgb; } +IfcColourRgb::IfcColourRgb(IfcAbstractEntityPtr e) { if (!is(Type::IfcColourRgb)) throw; entity = e; } +// IfcColourSpecification +bool IfcColourSpecification::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcColourSpecification::Name() { return *entity->getArgument(0); } +bool IfcColourSpecification::is(Type::Enum v) { return v == Type::IfcColourSpecification; } +Type::Enum IfcColourSpecification::type() { return Type::IfcColourSpecification; } +Type::Enum IfcColourSpecification::Class() { return Type::IfcColourSpecification; } +IfcColourSpecification::IfcColourSpecification(IfcAbstractEntityPtr e) { if (!is(Type::IfcColourSpecification)) throw; entity = e; } +// IfcColumn +bool IfcColumn::is(Type::Enum v) { return v == Type::IfcColumn || IfcBuildingElement::is(v); } +Type::Enum IfcColumn::type() { return Type::IfcColumn; } +Type::Enum IfcColumn::Class() { return Type::IfcColumn; } +IfcColumn::IfcColumn(IfcAbstractEntityPtr e) { if (!is(Type::IfcColumn)) throw; entity = e; } +// IfcColumnType +IfcColumnTypeEnum::IfcColumnTypeEnum IfcColumnType::PredefinedType() { return IfcColumnTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcColumnType::is(Type::Enum v) { return v == Type::IfcColumnType || IfcBuildingElementType::is(v); } +Type::Enum IfcColumnType::type() { return Type::IfcColumnType; } +Type::Enum IfcColumnType::Class() { return Type::IfcColumnType; } +IfcColumnType::IfcColumnType(IfcAbstractEntityPtr e) { if (!is(Type::IfcColumnType)) throw; entity = e; } +// IfcComplexProperty +IfcIdentifier IfcComplexProperty::UsageName() { return *entity->getArgument(2); } +SHARED_PTR< IfcTemplatedEntityList > IfcComplexProperty::HasProperties() { RETURN_AS_LIST(IfcProperty,3) } +bool IfcComplexProperty::is(Type::Enum v) { return v == Type::IfcComplexProperty || IfcProperty::is(v); } +Type::Enum IfcComplexProperty::type() { return Type::IfcComplexProperty; } +Type::Enum IfcComplexProperty::Class() { return Type::IfcComplexProperty; } +IfcComplexProperty::IfcComplexProperty(IfcAbstractEntityPtr e) { if (!is(Type::IfcComplexProperty)) throw; entity = e; } +// IfcCompositeCurve +SHARED_PTR< IfcTemplatedEntityList > IfcCompositeCurve::Segments() { RETURN_AS_LIST(IfcCompositeCurveSegment,0) } +bool IfcCompositeCurve::SelfIntersect() { return *entity->getArgument(1); } +bool IfcCompositeCurve::is(Type::Enum v) { return v == Type::IfcCompositeCurve || IfcBoundedCurve::is(v); } +Type::Enum IfcCompositeCurve::type() { return Type::IfcCompositeCurve; } +Type::Enum IfcCompositeCurve::Class() { return Type::IfcCompositeCurve; } +IfcCompositeCurve::IfcCompositeCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompositeCurve)) throw; entity = e; } +// IfcCompositeCurveSegment +IfcTransitionCode::IfcTransitionCode IfcCompositeCurveSegment::Transition() { return IfcTransitionCode::FromString(*entity->getArgument(0)); } +bool IfcCompositeCurveSegment::SameSense() { return *entity->getArgument(1); } +SHARED_PTR IfcCompositeCurveSegment::ParentCurve() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +IfcCompositeCurve::list IfcCompositeCurveSegment::UsingCurves() { RETURN_INVERSE(IfcCompositeCurve) } +bool IfcCompositeCurveSegment::is(Type::Enum v) { return v == Type::IfcCompositeCurveSegment || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcCompositeCurveSegment::type() { return Type::IfcCompositeCurveSegment; } +Type::Enum IfcCompositeCurveSegment::Class() { return Type::IfcCompositeCurveSegment; } +IfcCompositeCurveSegment::IfcCompositeCurveSegment(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompositeCurveSegment)) throw; entity = e; } +// IfcCompositeProfileDef +SHARED_PTR< IfcTemplatedEntityList > IfcCompositeProfileDef::Profiles() { RETURN_AS_LIST(IfcProfileDef,2) } +bool IfcCompositeProfileDef::hasLabel() { return !entity->getArgument(3)->isNull(); } +IfcLabel IfcCompositeProfileDef::Label() { return *entity->getArgument(3); } +bool IfcCompositeProfileDef::is(Type::Enum v) { return v == Type::IfcCompositeProfileDef || IfcProfileDef::is(v); } +Type::Enum IfcCompositeProfileDef::type() { return Type::IfcCompositeProfileDef; } +Type::Enum IfcCompositeProfileDef::Class() { return Type::IfcCompositeProfileDef; } +IfcCompositeProfileDef::IfcCompositeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompositeProfileDef)) throw; entity = e; } +// IfcCompressorType +IfcCompressorTypeEnum::IfcCompressorTypeEnum IfcCompressorType::PredefinedType() { return IfcCompressorTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcCompressorType::is(Type::Enum v) { return v == Type::IfcCompressorType || IfcFlowMovingDeviceType::is(v); } +Type::Enum IfcCompressorType::type() { return Type::IfcCompressorType; } +Type::Enum IfcCompressorType::Class() { return Type::IfcCompressorType; } +IfcCompressorType::IfcCompressorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompressorType)) throw; entity = e; } +// IfcCondenserType +IfcCondenserTypeEnum::IfcCondenserTypeEnum IfcCondenserType::PredefinedType() { return IfcCondenserTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcCondenserType::is(Type::Enum v) { return v == Type::IfcCondenserType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcCondenserType::type() { return Type::IfcCondenserType; } +Type::Enum IfcCondenserType::Class() { return Type::IfcCondenserType; } +IfcCondenserType::IfcCondenserType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCondenserType)) throw; entity = e; } +// IfcCondition +bool IfcCondition::is(Type::Enum v) { return v == Type::IfcCondition || IfcGroup::is(v); } +Type::Enum IfcCondition::type() { return Type::IfcCondition; } +Type::Enum IfcCondition::Class() { return Type::IfcCondition; } +IfcCondition::IfcCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcCondition)) throw; entity = e; } +// IfcConditionCriterion +IfcConditionCriterionSelect IfcConditionCriterion::Criterion() { return *entity->getArgument(5); } +IfcDateTimeSelect IfcConditionCriterion::CriterionDateTime() { return *entity->getArgument(6); } +bool IfcConditionCriterion::is(Type::Enum v) { return v == Type::IfcConditionCriterion || IfcControl::is(v); } +Type::Enum IfcConditionCriterion::type() { return Type::IfcConditionCriterion; } +Type::Enum IfcConditionCriterion::Class() { return Type::IfcConditionCriterion; } +IfcConditionCriterion::IfcConditionCriterion(IfcAbstractEntityPtr e) { if (!is(Type::IfcConditionCriterion)) throw; entity = e; } +// IfcConic +IfcAxis2Placement IfcConic::Position() { return *entity->getArgument(0); } +bool IfcConic::is(Type::Enum v) { return v == Type::IfcConic || IfcCurve::is(v); } +Type::Enum IfcConic::type() { return Type::IfcConic; } +Type::Enum IfcConic::Class() { return Type::IfcConic; } +IfcConic::IfcConic(IfcAbstractEntityPtr e) { if (!is(Type::IfcConic)) throw; entity = e; } +// IfcConnectedFaceSet +SHARED_PTR< IfcTemplatedEntityList > IfcConnectedFaceSet::CfsFaces() { RETURN_AS_LIST(IfcFace,0) } +bool IfcConnectedFaceSet::is(Type::Enum v) { return v == Type::IfcConnectedFaceSet || IfcTopologicalRepresentationItem::is(v); } +Type::Enum IfcConnectedFaceSet::type() { return Type::IfcConnectedFaceSet; } +Type::Enum IfcConnectedFaceSet::Class() { return Type::IfcConnectedFaceSet; } +IfcConnectedFaceSet::IfcConnectedFaceSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectedFaceSet)) throw; entity = e; } +// IfcConnectionCurveGeometry +IfcCurveOrEdgeCurve IfcConnectionCurveGeometry::CurveOnRelatingElement() { return *entity->getArgument(0); } +bool IfcConnectionCurveGeometry::hasCurveOnRelatedElement() { return !entity->getArgument(1)->isNull(); } +IfcCurveOrEdgeCurve IfcConnectionCurveGeometry::CurveOnRelatedElement() { return *entity->getArgument(1); } +bool IfcConnectionCurveGeometry::is(Type::Enum v) { return v == Type::IfcConnectionCurveGeometry || IfcConnectionGeometry::is(v); } +Type::Enum IfcConnectionCurveGeometry::type() { return Type::IfcConnectionCurveGeometry; } +Type::Enum IfcConnectionCurveGeometry::Class() { return Type::IfcConnectionCurveGeometry; } +IfcConnectionCurveGeometry::IfcConnectionCurveGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionCurveGeometry)) throw; entity = e; } +// IfcConnectionGeometry +bool IfcConnectionGeometry::is(Type::Enum v) { return v == Type::IfcConnectionGeometry; } +Type::Enum IfcConnectionGeometry::type() { return Type::IfcConnectionGeometry; } +Type::Enum IfcConnectionGeometry::Class() { return Type::IfcConnectionGeometry; } +IfcConnectionGeometry::IfcConnectionGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionGeometry)) throw; entity = e; } +// IfcConnectionPointEccentricity +bool IfcConnectionPointEccentricity::hasEccentricityInX() { return !entity->getArgument(2)->isNull(); } +IfcLengthMeasure IfcConnectionPointEccentricity::EccentricityInX() { return *entity->getArgument(2); } +bool IfcConnectionPointEccentricity::hasEccentricityInY() { return !entity->getArgument(3)->isNull(); } +IfcLengthMeasure IfcConnectionPointEccentricity::EccentricityInY() { return *entity->getArgument(3); } +bool IfcConnectionPointEccentricity::hasEccentricityInZ() { return !entity->getArgument(4)->isNull(); } +IfcLengthMeasure IfcConnectionPointEccentricity::EccentricityInZ() { return *entity->getArgument(4); } +bool IfcConnectionPointEccentricity::is(Type::Enum v) { return v == Type::IfcConnectionPointEccentricity || IfcConnectionPointGeometry::is(v); } +Type::Enum IfcConnectionPointEccentricity::type() { return Type::IfcConnectionPointEccentricity; } +Type::Enum IfcConnectionPointEccentricity::Class() { return Type::IfcConnectionPointEccentricity; } +IfcConnectionPointEccentricity::IfcConnectionPointEccentricity(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionPointEccentricity)) throw; entity = e; } +// IfcConnectionPointGeometry +IfcPointOrVertexPoint IfcConnectionPointGeometry::PointOnRelatingElement() { return *entity->getArgument(0); } +bool IfcConnectionPointGeometry::hasPointOnRelatedElement() { return !entity->getArgument(1)->isNull(); } +IfcPointOrVertexPoint IfcConnectionPointGeometry::PointOnRelatedElement() { return *entity->getArgument(1); } +bool IfcConnectionPointGeometry::is(Type::Enum v) { return v == Type::IfcConnectionPointGeometry || IfcConnectionGeometry::is(v); } +Type::Enum IfcConnectionPointGeometry::type() { return Type::IfcConnectionPointGeometry; } +Type::Enum IfcConnectionPointGeometry::Class() { return Type::IfcConnectionPointGeometry; } +IfcConnectionPointGeometry::IfcConnectionPointGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionPointGeometry)) throw; entity = e; } +// IfcConnectionPortGeometry +IfcAxis2Placement IfcConnectionPortGeometry::LocationAtRelatingElement() { return *entity->getArgument(0); } +bool IfcConnectionPortGeometry::hasLocationAtRelatedElement() { return !entity->getArgument(1)->isNull(); } +IfcAxis2Placement IfcConnectionPortGeometry::LocationAtRelatedElement() { return *entity->getArgument(1); } +SHARED_PTR IfcConnectionPortGeometry::ProfileOfPort() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcConnectionPortGeometry::is(Type::Enum v) { return v == Type::IfcConnectionPortGeometry || IfcConnectionGeometry::is(v); } +Type::Enum IfcConnectionPortGeometry::type() { return Type::IfcConnectionPortGeometry; } +Type::Enum IfcConnectionPortGeometry::Class() { return Type::IfcConnectionPortGeometry; } +IfcConnectionPortGeometry::IfcConnectionPortGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionPortGeometry)) throw; entity = e; } +// IfcConnectionSurfaceGeometry +IfcSurfaceOrFaceSurface IfcConnectionSurfaceGeometry::SurfaceOnRelatingElement() { return *entity->getArgument(0); } +bool IfcConnectionSurfaceGeometry::hasSurfaceOnRelatedElement() { return !entity->getArgument(1)->isNull(); } +IfcSurfaceOrFaceSurface IfcConnectionSurfaceGeometry::SurfaceOnRelatedElement() { return *entity->getArgument(1); } +bool IfcConnectionSurfaceGeometry::is(Type::Enum v) { return v == Type::IfcConnectionSurfaceGeometry || IfcConnectionGeometry::is(v); } +Type::Enum IfcConnectionSurfaceGeometry::type() { return Type::IfcConnectionSurfaceGeometry; } +Type::Enum IfcConnectionSurfaceGeometry::Class() { return Type::IfcConnectionSurfaceGeometry; } +IfcConnectionSurfaceGeometry::IfcConnectionSurfaceGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionSurfaceGeometry)) throw; entity = e; } +// IfcConstraint +IfcLabel IfcConstraint::Name() { return *entity->getArgument(0); } +bool IfcConstraint::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcConstraint::Description() { return *entity->getArgument(1); } +IfcConstraintEnum::IfcConstraintEnum IfcConstraint::ConstraintGrade() { return IfcConstraintEnum::FromString(*entity->getArgument(2)); } +bool IfcConstraint::hasConstraintSource() { return !entity->getArgument(3)->isNull(); } +IfcLabel IfcConstraint::ConstraintSource() { return *entity->getArgument(3); } +bool IfcConstraint::hasCreatingActor() { return !entity->getArgument(4)->isNull(); } +IfcActorSelect IfcConstraint::CreatingActor() { return *entity->getArgument(4); } +bool IfcConstraint::hasCreationTime() { return !entity->getArgument(5)->isNull(); } +IfcDateTimeSelect IfcConstraint::CreationTime() { return *entity->getArgument(5); } +bool IfcConstraint::hasUserDefinedGrade() { return !entity->getArgument(6)->isNull(); } +IfcLabel IfcConstraint::UserDefinedGrade() { return *entity->getArgument(6); } +IfcConstraintClassificationRelationship::list IfcConstraint::ClassifiedAs() { RETURN_INVERSE(IfcConstraintClassificationRelationship) } +IfcConstraintRelationship::list IfcConstraint::RelatesConstraints() { RETURN_INVERSE(IfcConstraintRelationship) } +IfcConstraintRelationship::list IfcConstraint::IsRelatedWith() { RETURN_INVERSE(IfcConstraintRelationship) } +IfcPropertyConstraintRelationship::list IfcConstraint::PropertiesForConstraint() { RETURN_INVERSE(IfcPropertyConstraintRelationship) } +IfcConstraintAggregationRelationship::list IfcConstraint::Aggregates() { RETURN_INVERSE(IfcConstraintAggregationRelationship) } +IfcConstraintAggregationRelationship::list IfcConstraint::IsAggregatedIn() { RETURN_INVERSE(IfcConstraintAggregationRelationship) } +bool IfcConstraint::is(Type::Enum v) { return v == Type::IfcConstraint; } +Type::Enum IfcConstraint::type() { return Type::IfcConstraint; } +Type::Enum IfcConstraint::Class() { return Type::IfcConstraint; } +IfcConstraint::IfcConstraint(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraint)) throw; entity = e; } +// IfcConstraintAggregationRelationship +bool IfcConstraintAggregationRelationship::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcConstraintAggregationRelationship::Name() { return *entity->getArgument(0); } +bool IfcConstraintAggregationRelationship::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcConstraintAggregationRelationship::Description() { return *entity->getArgument(1); } +SHARED_PTR IfcConstraintAggregationRelationship::RelatingConstraint() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +SHARED_PTR< IfcTemplatedEntityList > IfcConstraintAggregationRelationship::RelatedConstraints() { RETURN_AS_LIST(IfcConstraint,3) } +IfcLogicalOperatorEnum::IfcLogicalOperatorEnum IfcConstraintAggregationRelationship::LogicalAggregator() { return IfcLogicalOperatorEnum::FromString(*entity->getArgument(4)); } +bool IfcConstraintAggregationRelationship::is(Type::Enum v) { return v == Type::IfcConstraintAggregationRelationship; } +Type::Enum IfcConstraintAggregationRelationship::type() { return Type::IfcConstraintAggregationRelationship; } +Type::Enum IfcConstraintAggregationRelationship::Class() { return Type::IfcConstraintAggregationRelationship; } +IfcConstraintAggregationRelationship::IfcConstraintAggregationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraintAggregationRelationship)) throw; entity = e; } +// IfcConstraintClassificationRelationship +SHARED_PTR IfcConstraintClassificationRelationship::ClassifiedConstraint() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR< IfcTemplatedEntityList > IfcConstraintClassificationRelationship::RelatedClassifications() { RETURN_AS_LIST(IfcAbstractSelect,1) } +bool IfcConstraintClassificationRelationship::is(Type::Enum v) { return v == Type::IfcConstraintClassificationRelationship; } +Type::Enum IfcConstraintClassificationRelationship::type() { return Type::IfcConstraintClassificationRelationship; } +Type::Enum IfcConstraintClassificationRelationship::Class() { return Type::IfcConstraintClassificationRelationship; } +IfcConstraintClassificationRelationship::IfcConstraintClassificationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraintClassificationRelationship)) throw; entity = e; } +// IfcConstraintRelationship +bool IfcConstraintRelationship::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcConstraintRelationship::Name() { return *entity->getArgument(0); } +bool IfcConstraintRelationship::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcConstraintRelationship::Description() { return *entity->getArgument(1); } +SHARED_PTR IfcConstraintRelationship::RelatingConstraint() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +SHARED_PTR< IfcTemplatedEntityList > IfcConstraintRelationship::RelatedConstraints() { RETURN_AS_LIST(IfcConstraint,3) } +bool IfcConstraintRelationship::is(Type::Enum v) { return v == Type::IfcConstraintRelationship; } +Type::Enum IfcConstraintRelationship::type() { return Type::IfcConstraintRelationship; } +Type::Enum IfcConstraintRelationship::Class() { return Type::IfcConstraintRelationship; } +IfcConstraintRelationship::IfcConstraintRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraintRelationship)) throw; entity = e; } +// IfcConstructionEquipmentResource +bool IfcConstructionEquipmentResource::is(Type::Enum v) { return v == Type::IfcConstructionEquipmentResource || IfcConstructionResource::is(v); } +Type::Enum IfcConstructionEquipmentResource::type() { return Type::IfcConstructionEquipmentResource; } +Type::Enum IfcConstructionEquipmentResource::Class() { return Type::IfcConstructionEquipmentResource; } +IfcConstructionEquipmentResource::IfcConstructionEquipmentResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionEquipmentResource)) throw; entity = e; } +// IfcConstructionMaterialResource +bool IfcConstructionMaterialResource::hasSuppliers() { return !entity->getArgument(9)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcConstructionMaterialResource::Suppliers() { RETURN_AS_LIST(IfcAbstractSelect,9) } +bool IfcConstructionMaterialResource::hasUsageRatio() { return !entity->getArgument(10)->isNull(); } +IfcRatioMeasure IfcConstructionMaterialResource::UsageRatio() { return *entity->getArgument(10); } +bool IfcConstructionMaterialResource::is(Type::Enum v) { return v == Type::IfcConstructionMaterialResource || IfcConstructionResource::is(v); } +Type::Enum IfcConstructionMaterialResource::type() { return Type::IfcConstructionMaterialResource; } +Type::Enum IfcConstructionMaterialResource::Class() { return Type::IfcConstructionMaterialResource; } +IfcConstructionMaterialResource::IfcConstructionMaterialResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionMaterialResource)) throw; entity = e; } +// IfcConstructionProductResource +bool IfcConstructionProductResource::is(Type::Enum v) { return v == Type::IfcConstructionProductResource || IfcConstructionResource::is(v); } +Type::Enum IfcConstructionProductResource::type() { return Type::IfcConstructionProductResource; } +Type::Enum IfcConstructionProductResource::Class() { return Type::IfcConstructionProductResource; } +IfcConstructionProductResource::IfcConstructionProductResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionProductResource)) throw; entity = e; } +// IfcConstructionResource +bool IfcConstructionResource::hasResourceIdentifier() { return !entity->getArgument(5)->isNull(); } +IfcIdentifier IfcConstructionResource::ResourceIdentifier() { return *entity->getArgument(5); } +bool IfcConstructionResource::hasResourceGroup() { return !entity->getArgument(6)->isNull(); } +IfcLabel IfcConstructionResource::ResourceGroup() { return *entity->getArgument(6); } +bool IfcConstructionResource::hasResourceConsumption() { return !entity->getArgument(7)->isNull(); } +IfcResourceConsumptionEnum::IfcResourceConsumptionEnum IfcConstructionResource::ResourceConsumption() { return IfcResourceConsumptionEnum::FromString(*entity->getArgument(7)); } +bool IfcConstructionResource::hasBaseQuantity() { return !entity->getArgument(8)->isNull(); } +SHARED_PTR IfcConstructionResource::BaseQuantity() { return reinterpret_pointer_cast(*entity->getArgument(8)); } +bool IfcConstructionResource::is(Type::Enum v) { return v == Type::IfcConstructionResource || IfcResource::is(v); } +Type::Enum IfcConstructionResource::type() { return Type::IfcConstructionResource; } +Type::Enum IfcConstructionResource::Class() { return Type::IfcConstructionResource; } +IfcConstructionResource::IfcConstructionResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionResource)) throw; entity = e; } +// IfcContextDependentUnit +IfcLabel IfcContextDependentUnit::Name() { return *entity->getArgument(2); } +bool IfcContextDependentUnit::is(Type::Enum v) { return v == Type::IfcContextDependentUnit || IfcNamedUnit::is(v); } +Type::Enum IfcContextDependentUnit::type() { return Type::IfcContextDependentUnit; } +Type::Enum IfcContextDependentUnit::Class() { return Type::IfcContextDependentUnit; } +IfcContextDependentUnit::IfcContextDependentUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcContextDependentUnit)) throw; entity = e; } +// IfcControl +IfcRelAssignsToControl::list IfcControl::Controls() { RETURN_INVERSE(IfcRelAssignsToControl) } +bool IfcControl::is(Type::Enum v) { return v == Type::IfcControl || IfcObject::is(v); } +Type::Enum IfcControl::type() { return Type::IfcControl; } +Type::Enum IfcControl::Class() { return Type::IfcControl; } +IfcControl::IfcControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcControl)) throw; entity = e; } +// IfcControllerType +IfcControllerTypeEnum::IfcControllerTypeEnum IfcControllerType::PredefinedType() { return IfcControllerTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcControllerType::is(Type::Enum v) { return v == Type::IfcControllerType || IfcDistributionControlElementType::is(v); } +Type::Enum IfcControllerType::type() { return Type::IfcControllerType; } +Type::Enum IfcControllerType::Class() { return Type::IfcControllerType; } +IfcControllerType::IfcControllerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcControllerType)) throw; entity = e; } +// IfcConversionBasedUnit +IfcLabel IfcConversionBasedUnit::Name() { return *entity->getArgument(2); } +SHARED_PTR IfcConversionBasedUnit::ConversionFactor() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcConversionBasedUnit::is(Type::Enum v) { return v == Type::IfcConversionBasedUnit || IfcNamedUnit::is(v); } +Type::Enum IfcConversionBasedUnit::type() { return Type::IfcConversionBasedUnit; } +Type::Enum IfcConversionBasedUnit::Class() { return Type::IfcConversionBasedUnit; } +IfcConversionBasedUnit::IfcConversionBasedUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcConversionBasedUnit)) throw; entity = e; } +// IfcCooledBeamType +IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum IfcCooledBeamType::PredefinedType() { return IfcCooledBeamTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcCooledBeamType::is(Type::Enum v) { return v == Type::IfcCooledBeamType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcCooledBeamType::type() { return Type::IfcCooledBeamType; } +Type::Enum IfcCooledBeamType::Class() { return Type::IfcCooledBeamType; } +IfcCooledBeamType::IfcCooledBeamType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCooledBeamType)) throw; entity = e; } +// IfcCoolingTowerType +IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum IfcCoolingTowerType::PredefinedType() { return IfcCoolingTowerTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcCoolingTowerType::is(Type::Enum v) { return v == Type::IfcCoolingTowerType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcCoolingTowerType::type() { return Type::IfcCoolingTowerType; } +Type::Enum IfcCoolingTowerType::Class() { return Type::IfcCoolingTowerType; } +IfcCoolingTowerType::IfcCoolingTowerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoolingTowerType)) throw; entity = e; } +// IfcCoordinatedUniversalTimeOffset +IfcHourInDay IfcCoordinatedUniversalTimeOffset::HourOffset() { return *entity->getArgument(0); } +bool IfcCoordinatedUniversalTimeOffset::hasMinuteOffset() { return !entity->getArgument(1)->isNull(); } +IfcMinuteInHour IfcCoordinatedUniversalTimeOffset::MinuteOffset() { return *entity->getArgument(1); } +IfcAheadOrBehind::IfcAheadOrBehind IfcCoordinatedUniversalTimeOffset::Sense() { return IfcAheadOrBehind::FromString(*entity->getArgument(2)); } +bool IfcCoordinatedUniversalTimeOffset::is(Type::Enum v) { return v == Type::IfcCoordinatedUniversalTimeOffset; } +Type::Enum IfcCoordinatedUniversalTimeOffset::type() { return Type::IfcCoordinatedUniversalTimeOffset; } +Type::Enum IfcCoordinatedUniversalTimeOffset::Class() { return Type::IfcCoordinatedUniversalTimeOffset; } +IfcCoordinatedUniversalTimeOffset::IfcCoordinatedUniversalTimeOffset(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoordinatedUniversalTimeOffset)) throw; entity = e; } +// IfcCostItem +bool IfcCostItem::is(Type::Enum v) { return v == Type::IfcCostItem || IfcControl::is(v); } +Type::Enum IfcCostItem::type() { return Type::IfcCostItem; } +Type::Enum IfcCostItem::Class() { return Type::IfcCostItem; } +IfcCostItem::IfcCostItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcCostItem)) throw; entity = e; } +// IfcCostSchedule +bool IfcCostSchedule::hasSubmittedBy() { return !entity->getArgument(5)->isNull(); } +IfcActorSelect IfcCostSchedule::SubmittedBy() { return *entity->getArgument(5); } +bool IfcCostSchedule::hasPreparedBy() { return !entity->getArgument(6)->isNull(); } +IfcActorSelect IfcCostSchedule::PreparedBy() { return *entity->getArgument(6); } +bool IfcCostSchedule::hasSubmittedOn() { return !entity->getArgument(7)->isNull(); } +IfcDateTimeSelect IfcCostSchedule::SubmittedOn() { return *entity->getArgument(7); } +bool IfcCostSchedule::hasStatus() { return !entity->getArgument(8)->isNull(); } +IfcLabel IfcCostSchedule::Status() { return *entity->getArgument(8); } +bool IfcCostSchedule::hasTargetUsers() { return !entity->getArgument(9)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcCostSchedule::TargetUsers() { RETURN_AS_LIST(IfcAbstractSelect,9) } +bool IfcCostSchedule::hasUpdateDate() { return !entity->getArgument(10)->isNull(); } +IfcDateTimeSelect IfcCostSchedule::UpdateDate() { return *entity->getArgument(10); } +IfcIdentifier IfcCostSchedule::ID() { return *entity->getArgument(11); } +IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum IfcCostSchedule::PredefinedType() { return IfcCostScheduleTypeEnum::FromString(*entity->getArgument(12)); } +bool IfcCostSchedule::is(Type::Enum v) { return v == Type::IfcCostSchedule || IfcControl::is(v); } +Type::Enum IfcCostSchedule::type() { return Type::IfcCostSchedule; } +Type::Enum IfcCostSchedule::Class() { return Type::IfcCostSchedule; } +IfcCostSchedule::IfcCostSchedule(IfcAbstractEntityPtr e) { if (!is(Type::IfcCostSchedule)) throw; entity = e; } +// IfcCostValue +IfcLabel IfcCostValue::CostType() { return *entity->getArgument(6); } +bool IfcCostValue::hasCondition() { return !entity->getArgument(7)->isNull(); } +IfcText IfcCostValue::Condition() { return *entity->getArgument(7); } +bool IfcCostValue::is(Type::Enum v) { return v == Type::IfcCostValue || IfcAppliedValue::is(v); } +Type::Enum IfcCostValue::type() { return Type::IfcCostValue; } +Type::Enum IfcCostValue::Class() { return Type::IfcCostValue; } +IfcCostValue::IfcCostValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcCostValue)) throw; entity = e; } +// IfcCovering +bool IfcCovering::hasPredefinedType() { return !entity->getArgument(8)->isNull(); } +IfcCoveringTypeEnum::IfcCoveringTypeEnum IfcCovering::PredefinedType() { return IfcCoveringTypeEnum::FromString(*entity->getArgument(8)); } +IfcRelCoversSpaces::list IfcCovering::CoversSpaces() { RETURN_INVERSE(IfcRelCoversSpaces) } +IfcRelCoversBldgElements::list IfcCovering::Covers() { RETURN_INVERSE(IfcRelCoversBldgElements) } +bool IfcCovering::is(Type::Enum v) { return v == Type::IfcCovering || IfcBuildingElement::is(v); } +Type::Enum IfcCovering::type() { return Type::IfcCovering; } +Type::Enum IfcCovering::Class() { return Type::IfcCovering; } +IfcCovering::IfcCovering(IfcAbstractEntityPtr e) { if (!is(Type::IfcCovering)) throw; entity = e; } +// IfcCoveringType +IfcCoveringTypeEnum::IfcCoveringTypeEnum IfcCoveringType::PredefinedType() { return IfcCoveringTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcCoveringType::is(Type::Enum v) { return v == Type::IfcCoveringType || IfcBuildingElementType::is(v); } +Type::Enum IfcCoveringType::type() { return Type::IfcCoveringType; } +Type::Enum IfcCoveringType::Class() { return Type::IfcCoveringType; } +IfcCoveringType::IfcCoveringType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoveringType)) throw; entity = e; } +// IfcCraneRailAShapeProfileDef +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::OverallHeight() { return *entity->getArgument(3); } +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::BaseWidth2() { return *entity->getArgument(4); } +bool IfcCraneRailAShapeProfileDef::hasRadius() { return !entity->getArgument(5)->isNull(); } +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::Radius() { return *entity->getArgument(5); } +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::HeadWidth() { return *entity->getArgument(6); } +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::HeadDepth2() { return *entity->getArgument(7); } +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::HeadDepth3() { return *entity->getArgument(8); } +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::WebThickness() { return *entity->getArgument(9); } +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::BaseWidth4() { return *entity->getArgument(10); } +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::BaseDepth1() { return *entity->getArgument(11); } +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::BaseDepth2() { return *entity->getArgument(12); } +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::BaseDepth3() { return *entity->getArgument(13); } +bool IfcCraneRailAShapeProfileDef::hasCentreOfGravityInY() { return !entity->getArgument(14)->isNull(); } +IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::CentreOfGravityInY() { return *entity->getArgument(14); } +bool IfcCraneRailAShapeProfileDef::is(Type::Enum v) { return v == Type::IfcCraneRailAShapeProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcCraneRailAShapeProfileDef::type() { return Type::IfcCraneRailAShapeProfileDef; } +Type::Enum IfcCraneRailAShapeProfileDef::Class() { return Type::IfcCraneRailAShapeProfileDef; } +IfcCraneRailAShapeProfileDef::IfcCraneRailAShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCraneRailAShapeProfileDef)) throw; entity = e; } +// IfcCraneRailFShapeProfileDef +IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::OverallHeight() { return *entity->getArgument(3); } +IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::HeadWidth() { return *entity->getArgument(4); } +bool IfcCraneRailFShapeProfileDef::hasRadius() { return !entity->getArgument(5)->isNull(); } +IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::Radius() { return *entity->getArgument(5); } +IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::HeadDepth2() { return *entity->getArgument(6); } +IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::HeadDepth3() { return *entity->getArgument(7); } +IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::WebThickness() { return *entity->getArgument(8); } +IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::BaseDepth1() { return *entity->getArgument(9); } +IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::BaseDepth2() { return *entity->getArgument(10); } +bool IfcCraneRailFShapeProfileDef::hasCentreOfGravityInY() { return !entity->getArgument(11)->isNull(); } +IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::CentreOfGravityInY() { return *entity->getArgument(11); } +bool IfcCraneRailFShapeProfileDef::is(Type::Enum v) { return v == Type::IfcCraneRailFShapeProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcCraneRailFShapeProfileDef::type() { return Type::IfcCraneRailFShapeProfileDef; } +Type::Enum IfcCraneRailFShapeProfileDef::Class() { return Type::IfcCraneRailFShapeProfileDef; } +IfcCraneRailFShapeProfileDef::IfcCraneRailFShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCraneRailFShapeProfileDef)) throw; entity = e; } +// IfcCrewResource +bool IfcCrewResource::is(Type::Enum v) { return v == Type::IfcCrewResource || IfcConstructionResource::is(v); } +Type::Enum IfcCrewResource::type() { return Type::IfcCrewResource; } +Type::Enum IfcCrewResource::Class() { return Type::IfcCrewResource; } +IfcCrewResource::IfcCrewResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcCrewResource)) throw; entity = e; } +// IfcCsgPrimitive3D +SHARED_PTR IfcCsgPrimitive3D::Position() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcCsgPrimitive3D::is(Type::Enum v) { return v == Type::IfcCsgPrimitive3D || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcCsgPrimitive3D::type() { return Type::IfcCsgPrimitive3D; } +Type::Enum IfcCsgPrimitive3D::Class() { return Type::IfcCsgPrimitive3D; } +IfcCsgPrimitive3D::IfcCsgPrimitive3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcCsgPrimitive3D)) throw; entity = e; } +// IfcCsgSolid +IfcCsgSelect IfcCsgSolid::TreeRootExpression() { return *entity->getArgument(0); } +bool IfcCsgSolid::is(Type::Enum v) { return v == Type::IfcCsgSolid || IfcSolidModel::is(v); } +Type::Enum IfcCsgSolid::type() { return Type::IfcCsgSolid; } +Type::Enum IfcCsgSolid::Class() { return Type::IfcCsgSolid; } +IfcCsgSolid::IfcCsgSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcCsgSolid)) throw; entity = e; } +// IfcCurrencyRelationship +SHARED_PTR IfcCurrencyRelationship::RelatingMonetaryUnit() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcCurrencyRelationship::RelatedMonetaryUnit() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +IfcPositiveRatioMeasure IfcCurrencyRelationship::ExchangeRate() { return *entity->getArgument(2); } +SHARED_PTR IfcCurrencyRelationship::RateDateTime() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcCurrencyRelationship::hasRateSource() { return !entity->getArgument(4)->isNull(); } +SHARED_PTR IfcCurrencyRelationship::RateSource() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +bool IfcCurrencyRelationship::is(Type::Enum v) { return v == Type::IfcCurrencyRelationship; } +Type::Enum IfcCurrencyRelationship::type() { return Type::IfcCurrencyRelationship; } +Type::Enum IfcCurrencyRelationship::Class() { return Type::IfcCurrencyRelationship; } +IfcCurrencyRelationship::IfcCurrencyRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurrencyRelationship)) throw; entity = e; } +// IfcCurtainWall +bool IfcCurtainWall::is(Type::Enum v) { return v == Type::IfcCurtainWall || IfcBuildingElement::is(v); } +Type::Enum IfcCurtainWall::type() { return Type::IfcCurtainWall; } +Type::Enum IfcCurtainWall::Class() { return Type::IfcCurtainWall; } +IfcCurtainWall::IfcCurtainWall(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurtainWall)) throw; entity = e; } +// IfcCurtainWallType +IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum IfcCurtainWallType::PredefinedType() { return IfcCurtainWallTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcCurtainWallType::is(Type::Enum v) { return v == Type::IfcCurtainWallType || IfcBuildingElementType::is(v); } +Type::Enum IfcCurtainWallType::type() { return Type::IfcCurtainWallType; } +Type::Enum IfcCurtainWallType::Class() { return Type::IfcCurtainWallType; } +IfcCurtainWallType::IfcCurtainWallType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurtainWallType)) throw; entity = e; } +// IfcCurve +bool IfcCurve::is(Type::Enum v) { return v == Type::IfcCurve || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcCurve::type() { return Type::IfcCurve; } +Type::Enum IfcCurve::Class() { return Type::IfcCurve; } +IfcCurve::IfcCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurve)) throw; entity = e; } +// IfcCurveBoundedPlane +SHARED_PTR IfcCurveBoundedPlane::BasisSurface() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcCurveBoundedPlane::OuterBoundary() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +SHARED_PTR< IfcTemplatedEntityList > IfcCurveBoundedPlane::InnerBoundaries() { RETURN_AS_LIST(IfcCurve,2) } +bool IfcCurveBoundedPlane::is(Type::Enum v) { return v == Type::IfcCurveBoundedPlane || IfcBoundedSurface::is(v); } +Type::Enum IfcCurveBoundedPlane::type() { return Type::IfcCurveBoundedPlane; } +Type::Enum IfcCurveBoundedPlane::Class() { return Type::IfcCurveBoundedPlane; } +IfcCurveBoundedPlane::IfcCurveBoundedPlane(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveBoundedPlane)) throw; entity = e; } +// IfcCurveStyle +bool IfcCurveStyle::hasCurveFont() { return !entity->getArgument(1)->isNull(); } +IfcCurveFontOrScaledCurveFontSelect IfcCurveStyle::CurveFont() { return *entity->getArgument(1); } +bool IfcCurveStyle::hasCurveWidth() { return !entity->getArgument(2)->isNull(); } +IfcSizeSelect IfcCurveStyle::CurveWidth() { return *entity->getArgument(2); } +bool IfcCurveStyle::hasCurveColour() { return !entity->getArgument(3)->isNull(); } +IfcColour IfcCurveStyle::CurveColour() { return *entity->getArgument(3); } +bool IfcCurveStyle::is(Type::Enum v) { return v == Type::IfcCurveStyle || IfcPresentationStyle::is(v); } +Type::Enum IfcCurveStyle::type() { return Type::IfcCurveStyle; } +Type::Enum IfcCurveStyle::Class() { return Type::IfcCurveStyle; } +IfcCurveStyle::IfcCurveStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyle)) throw; entity = e; } +// IfcCurveStyleFont +bool IfcCurveStyleFont::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcCurveStyleFont::Name() { return *entity->getArgument(0); } +SHARED_PTR< IfcTemplatedEntityList > IfcCurveStyleFont::PatternList() { RETURN_AS_LIST(IfcCurveStyleFontPattern,1) } +bool IfcCurveStyleFont::is(Type::Enum v) { return v == Type::IfcCurveStyleFont; } +Type::Enum IfcCurveStyleFont::type() { return Type::IfcCurveStyleFont; } +Type::Enum IfcCurveStyleFont::Class() { return Type::IfcCurveStyleFont; } +IfcCurveStyleFont::IfcCurveStyleFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyleFont)) throw; entity = e; } +// IfcCurveStyleFontAndScaling +bool IfcCurveStyleFontAndScaling::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcCurveStyleFontAndScaling::Name() { return *entity->getArgument(0); } +IfcCurveStyleFontSelect IfcCurveStyleFontAndScaling::CurveFont() { return *entity->getArgument(1); } +IfcPositiveRatioMeasure IfcCurveStyleFontAndScaling::CurveFontScaling() { return *entity->getArgument(2); } +bool IfcCurveStyleFontAndScaling::is(Type::Enum v) { return v == Type::IfcCurveStyleFontAndScaling; } +Type::Enum IfcCurveStyleFontAndScaling::type() { return Type::IfcCurveStyleFontAndScaling; } +Type::Enum IfcCurveStyleFontAndScaling::Class() { return Type::IfcCurveStyleFontAndScaling; } +IfcCurveStyleFontAndScaling::IfcCurveStyleFontAndScaling(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyleFontAndScaling)) throw; entity = e; } +// IfcCurveStyleFontPattern +IfcLengthMeasure IfcCurveStyleFontPattern::VisibleSegmentLength() { return *entity->getArgument(0); } +IfcPositiveLengthMeasure IfcCurveStyleFontPattern::InvisibleSegmentLength() { return *entity->getArgument(1); } +bool IfcCurveStyleFontPattern::is(Type::Enum v) { return v == Type::IfcCurveStyleFontPattern; } +Type::Enum IfcCurveStyleFontPattern::type() { return Type::IfcCurveStyleFontPattern; } +Type::Enum IfcCurveStyleFontPattern::Class() { return Type::IfcCurveStyleFontPattern; } +IfcCurveStyleFontPattern::IfcCurveStyleFontPattern(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyleFontPattern)) throw; entity = e; } +// IfcDamperType +IfcDamperTypeEnum::IfcDamperTypeEnum IfcDamperType::PredefinedType() { return IfcDamperTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcDamperType::is(Type::Enum v) { return v == Type::IfcDamperType || IfcFlowControllerType::is(v); } +Type::Enum IfcDamperType::type() { return Type::IfcDamperType; } +Type::Enum IfcDamperType::Class() { return Type::IfcDamperType; } +IfcDamperType::IfcDamperType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDamperType)) throw; entity = e; } +// IfcDateAndTime +SHARED_PTR IfcDateAndTime::DateComponent() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcDateAndTime::TimeComponent() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcDateAndTime::is(Type::Enum v) { return v == Type::IfcDateAndTime; } +Type::Enum IfcDateAndTime::type() { return Type::IfcDateAndTime; } +Type::Enum IfcDateAndTime::Class() { return Type::IfcDateAndTime; } +IfcDateAndTime::IfcDateAndTime(IfcAbstractEntityPtr e) { if (!is(Type::IfcDateAndTime)) throw; entity = e; } +// IfcDefinedSymbol +IfcDefinedSymbolSelect IfcDefinedSymbol::Definition() { return *entity->getArgument(0); } +SHARED_PTR IfcDefinedSymbol::Target() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcDefinedSymbol::is(Type::Enum v) { return v == Type::IfcDefinedSymbol || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcDefinedSymbol::type() { return Type::IfcDefinedSymbol; } +Type::Enum IfcDefinedSymbol::Class() { return Type::IfcDefinedSymbol; } +IfcDefinedSymbol::IfcDefinedSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcDefinedSymbol)) throw; entity = e; } +// IfcDerivedProfileDef +SHARED_PTR IfcDerivedProfileDef::ParentProfile() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +SHARED_PTR IfcDerivedProfileDef::Operator() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcDerivedProfileDef::hasLabel() { return !entity->getArgument(4)->isNull(); } +IfcLabel IfcDerivedProfileDef::Label() { return *entity->getArgument(4); } +bool IfcDerivedProfileDef::is(Type::Enum v) { return v == Type::IfcDerivedProfileDef || IfcProfileDef::is(v); } +Type::Enum IfcDerivedProfileDef::type() { return Type::IfcDerivedProfileDef; } +Type::Enum IfcDerivedProfileDef::Class() { return Type::IfcDerivedProfileDef; } +IfcDerivedProfileDef::IfcDerivedProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcDerivedProfileDef)) throw; entity = e; } +// IfcDerivedUnit +SHARED_PTR< IfcTemplatedEntityList > IfcDerivedUnit::Elements() { RETURN_AS_LIST(IfcDerivedUnitElement,0) } +IfcDerivedUnitEnum::IfcDerivedUnitEnum IfcDerivedUnit::UnitType() { return IfcDerivedUnitEnum::FromString(*entity->getArgument(1)); } +bool IfcDerivedUnit::hasUserDefinedType() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcDerivedUnit::UserDefinedType() { return *entity->getArgument(2); } +bool IfcDerivedUnit::is(Type::Enum v) { return v == Type::IfcDerivedUnit; } +Type::Enum IfcDerivedUnit::type() { return Type::IfcDerivedUnit; } +Type::Enum IfcDerivedUnit::Class() { return Type::IfcDerivedUnit; } +IfcDerivedUnit::IfcDerivedUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcDerivedUnit)) throw; entity = e; } +// IfcDerivedUnitElement +SHARED_PTR IfcDerivedUnitElement::Unit() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +int IfcDerivedUnitElement::Exponent() { return *entity->getArgument(1); } +bool IfcDerivedUnitElement::is(Type::Enum v) { return v == Type::IfcDerivedUnitElement; } +Type::Enum IfcDerivedUnitElement::type() { return Type::IfcDerivedUnitElement; } +Type::Enum IfcDerivedUnitElement::Class() { return Type::IfcDerivedUnitElement; } +IfcDerivedUnitElement::IfcDerivedUnitElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDerivedUnitElement)) throw; entity = e; } +// IfcDiameterDimension +bool IfcDiameterDimension::is(Type::Enum v) { return v == Type::IfcDiameterDimension || IfcDimensionCurveDirectedCallout::is(v); } +Type::Enum IfcDiameterDimension::type() { return Type::IfcDiameterDimension; } +Type::Enum IfcDiameterDimension::Class() { return Type::IfcDiameterDimension; } +IfcDiameterDimension::IfcDiameterDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcDiameterDimension)) throw; entity = e; } +// IfcDimensionCalloutRelationship +bool IfcDimensionCalloutRelationship::is(Type::Enum v) { return v == Type::IfcDimensionCalloutRelationship || IfcDraughtingCalloutRelationship::is(v); } +Type::Enum IfcDimensionCalloutRelationship::type() { return Type::IfcDimensionCalloutRelationship; } +Type::Enum IfcDimensionCalloutRelationship::Class() { return Type::IfcDimensionCalloutRelationship; } +IfcDimensionCalloutRelationship::IfcDimensionCalloutRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCalloutRelationship)) throw; entity = e; } +// IfcDimensionCurve +IfcTerminatorSymbol::list IfcDimensionCurve::AnnotatedBySymbols() { RETURN_INVERSE(IfcTerminatorSymbol) } +bool IfcDimensionCurve::is(Type::Enum v) { return v == Type::IfcDimensionCurve || IfcAnnotationCurveOccurrence::is(v); } +Type::Enum IfcDimensionCurve::type() { return Type::IfcDimensionCurve; } +Type::Enum IfcDimensionCurve::Class() { return Type::IfcDimensionCurve; } +IfcDimensionCurve::IfcDimensionCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCurve)) throw; entity = e; } +// IfcDimensionCurveDirectedCallout +bool IfcDimensionCurveDirectedCallout::is(Type::Enum v) { return v == Type::IfcDimensionCurveDirectedCallout || IfcDraughtingCallout::is(v); } +Type::Enum IfcDimensionCurveDirectedCallout::type() { return Type::IfcDimensionCurveDirectedCallout; } +Type::Enum IfcDimensionCurveDirectedCallout::Class() { return Type::IfcDimensionCurveDirectedCallout; } +IfcDimensionCurveDirectedCallout::IfcDimensionCurveDirectedCallout(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCurveDirectedCallout)) throw; entity = e; } +// IfcDimensionCurveTerminator +IfcDimensionExtentUsage::IfcDimensionExtentUsage IfcDimensionCurveTerminator::Role() { return IfcDimensionExtentUsage::FromString(*entity->getArgument(4)); } +bool IfcDimensionCurveTerminator::is(Type::Enum v) { return v == Type::IfcDimensionCurveTerminator || IfcTerminatorSymbol::is(v); } +Type::Enum IfcDimensionCurveTerminator::type() { return Type::IfcDimensionCurveTerminator; } +Type::Enum IfcDimensionCurveTerminator::Class() { return Type::IfcDimensionCurveTerminator; } +IfcDimensionCurveTerminator::IfcDimensionCurveTerminator(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCurveTerminator)) throw; entity = e; } +// IfcDimensionPair +bool IfcDimensionPair::is(Type::Enum v) { return v == Type::IfcDimensionPair || IfcDraughtingCalloutRelationship::is(v); } +Type::Enum IfcDimensionPair::type() { return Type::IfcDimensionPair; } +Type::Enum IfcDimensionPair::Class() { return Type::IfcDimensionPair; } +IfcDimensionPair::IfcDimensionPair(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionPair)) throw; entity = e; } +// IfcDimensionalExponents +int IfcDimensionalExponents::LengthExponent() { return *entity->getArgument(0); } +int IfcDimensionalExponents::MassExponent() { return *entity->getArgument(1); } +int IfcDimensionalExponents::TimeExponent() { return *entity->getArgument(2); } +int IfcDimensionalExponents::ElectricCurrentExponent() { return *entity->getArgument(3); } +int IfcDimensionalExponents::ThermodynamicTemperatureExponent() { return *entity->getArgument(4); } +int IfcDimensionalExponents::AmountOfSubstanceExponent() { return *entity->getArgument(5); } +int IfcDimensionalExponents::LuminousIntensityExponent() { return *entity->getArgument(6); } +bool IfcDimensionalExponents::is(Type::Enum v) { return v == Type::IfcDimensionalExponents; } +Type::Enum IfcDimensionalExponents::type() { return Type::IfcDimensionalExponents; } +Type::Enum IfcDimensionalExponents::Class() { return Type::IfcDimensionalExponents; } +IfcDimensionalExponents::IfcDimensionalExponents(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionalExponents)) throw; entity = e; } +// IfcDirection +std::vector IfcDirection::DirectionRatios() { return *entity->getArgument(0); } +bool IfcDirection::is(Type::Enum v) { return v == Type::IfcDirection || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcDirection::type() { return Type::IfcDirection; } +Type::Enum IfcDirection::Class() { return Type::IfcDirection; } +IfcDirection::IfcDirection(IfcAbstractEntityPtr e) { if (!is(Type::IfcDirection)) throw; entity = e; } +// IfcDiscreteAccessory +bool IfcDiscreteAccessory::is(Type::Enum v) { return v == Type::IfcDiscreteAccessory || IfcElementComponent::is(v); } +Type::Enum IfcDiscreteAccessory::type() { return Type::IfcDiscreteAccessory; } +Type::Enum IfcDiscreteAccessory::Class() { return Type::IfcDiscreteAccessory; } +IfcDiscreteAccessory::IfcDiscreteAccessory(IfcAbstractEntityPtr e) { if (!is(Type::IfcDiscreteAccessory)) throw; entity = e; } +// IfcDiscreteAccessoryType +bool IfcDiscreteAccessoryType::is(Type::Enum v) { return v == Type::IfcDiscreteAccessoryType || IfcElementComponentType::is(v); } +Type::Enum IfcDiscreteAccessoryType::type() { return Type::IfcDiscreteAccessoryType; } +Type::Enum IfcDiscreteAccessoryType::Class() { return Type::IfcDiscreteAccessoryType; } +IfcDiscreteAccessoryType::IfcDiscreteAccessoryType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDiscreteAccessoryType)) throw; entity = e; } +// IfcDistributionChamberElement +bool IfcDistributionChamberElement::is(Type::Enum v) { return v == Type::IfcDistributionChamberElement || IfcDistributionFlowElement::is(v); } +Type::Enum IfcDistributionChamberElement::type() { return Type::IfcDistributionChamberElement; } +Type::Enum IfcDistributionChamberElement::Class() { return Type::IfcDistributionChamberElement; } +IfcDistributionChamberElement::IfcDistributionChamberElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionChamberElement)) throw; entity = e; } +// IfcDistributionChamberElementType +IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum IfcDistributionChamberElementType::PredefinedType() { return IfcDistributionChamberElementTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcDistributionChamberElementType::is(Type::Enum v) { return v == Type::IfcDistributionChamberElementType || IfcDistributionFlowElementType::is(v); } +Type::Enum IfcDistributionChamberElementType::type() { return Type::IfcDistributionChamberElementType; } +Type::Enum IfcDistributionChamberElementType::Class() { return Type::IfcDistributionChamberElementType; } +IfcDistributionChamberElementType::IfcDistributionChamberElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionChamberElementType)) throw; entity = e; } +// IfcDistributionControlElement +bool IfcDistributionControlElement::hasControlElementId() { return !entity->getArgument(8)->isNull(); } +IfcIdentifier IfcDistributionControlElement::ControlElementId() { return *entity->getArgument(8); } +IfcRelFlowControlElements::list IfcDistributionControlElement::AssignedToFlowElement() { RETURN_INVERSE(IfcRelFlowControlElements) } +bool IfcDistributionControlElement::is(Type::Enum v) { return v == Type::IfcDistributionControlElement || IfcDistributionElement::is(v); } +Type::Enum IfcDistributionControlElement::type() { return Type::IfcDistributionControlElement; } +Type::Enum IfcDistributionControlElement::Class() { return Type::IfcDistributionControlElement; } +IfcDistributionControlElement::IfcDistributionControlElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionControlElement)) throw; entity = e; } +// IfcDistributionControlElementType +bool IfcDistributionControlElementType::is(Type::Enum v) { return v == Type::IfcDistributionControlElementType || IfcDistributionElementType::is(v); } +Type::Enum IfcDistributionControlElementType::type() { return Type::IfcDistributionControlElementType; } +Type::Enum IfcDistributionControlElementType::Class() { return Type::IfcDistributionControlElementType; } +IfcDistributionControlElementType::IfcDistributionControlElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionControlElementType)) throw; entity = e; } +// IfcDistributionElement +bool IfcDistributionElement::is(Type::Enum v) { return v == Type::IfcDistributionElement || IfcElement::is(v); } +Type::Enum IfcDistributionElement::type() { return Type::IfcDistributionElement; } +Type::Enum IfcDistributionElement::Class() { return Type::IfcDistributionElement; } +IfcDistributionElement::IfcDistributionElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionElement)) throw; entity = e; } +// IfcDistributionElementType +bool IfcDistributionElementType::is(Type::Enum v) { return v == Type::IfcDistributionElementType || IfcElementType::is(v); } +Type::Enum IfcDistributionElementType::type() { return Type::IfcDistributionElementType; } +Type::Enum IfcDistributionElementType::Class() { return Type::IfcDistributionElementType; } +IfcDistributionElementType::IfcDistributionElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionElementType)) throw; entity = e; } +// IfcDistributionFlowElement +IfcRelFlowControlElements::list IfcDistributionFlowElement::HasControlElements() { RETURN_INVERSE(IfcRelFlowControlElements) } +bool IfcDistributionFlowElement::is(Type::Enum v) { return v == Type::IfcDistributionFlowElement || IfcDistributionElement::is(v); } +Type::Enum IfcDistributionFlowElement::type() { return Type::IfcDistributionFlowElement; } +Type::Enum IfcDistributionFlowElement::Class() { return Type::IfcDistributionFlowElement; } +IfcDistributionFlowElement::IfcDistributionFlowElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionFlowElement)) throw; entity = e; } +// IfcDistributionFlowElementType +bool IfcDistributionFlowElementType::is(Type::Enum v) { return v == Type::IfcDistributionFlowElementType || IfcDistributionElementType::is(v); } +Type::Enum IfcDistributionFlowElementType::type() { return Type::IfcDistributionFlowElementType; } +Type::Enum IfcDistributionFlowElementType::Class() { return Type::IfcDistributionFlowElementType; } +IfcDistributionFlowElementType::IfcDistributionFlowElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionFlowElementType)) throw; entity = e; } +// IfcDistributionPort +bool IfcDistributionPort::hasFlowDirection() { return !entity->getArgument(7)->isNull(); } +IfcFlowDirectionEnum::IfcFlowDirectionEnum IfcDistributionPort::FlowDirection() { return IfcFlowDirectionEnum::FromString(*entity->getArgument(7)); } +bool IfcDistributionPort::is(Type::Enum v) { return v == Type::IfcDistributionPort || IfcPort::is(v); } +Type::Enum IfcDistributionPort::type() { return Type::IfcDistributionPort; } +Type::Enum IfcDistributionPort::Class() { return Type::IfcDistributionPort; } +IfcDistributionPort::IfcDistributionPort(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionPort)) throw; entity = e; } +// IfcDocumentElectronicFormat +bool IfcDocumentElectronicFormat::hasFileExtension() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcDocumentElectronicFormat::FileExtension() { return *entity->getArgument(0); } +bool IfcDocumentElectronicFormat::hasMimeContentType() { return !entity->getArgument(1)->isNull(); } +IfcLabel IfcDocumentElectronicFormat::MimeContentType() { return *entity->getArgument(1); } +bool IfcDocumentElectronicFormat::hasMimeSubtype() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcDocumentElectronicFormat::MimeSubtype() { return *entity->getArgument(2); } +bool IfcDocumentElectronicFormat::is(Type::Enum v) { return v == Type::IfcDocumentElectronicFormat; } +Type::Enum IfcDocumentElectronicFormat::type() { return Type::IfcDocumentElectronicFormat; } +Type::Enum IfcDocumentElectronicFormat::Class() { return Type::IfcDocumentElectronicFormat; } +IfcDocumentElectronicFormat::IfcDocumentElectronicFormat(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentElectronicFormat)) throw; entity = e; } +// IfcDocumentInformation +IfcIdentifier IfcDocumentInformation::DocumentId() { return *entity->getArgument(0); } +IfcLabel IfcDocumentInformation::Name() { return *entity->getArgument(1); } +bool IfcDocumentInformation::hasDescription() { return !entity->getArgument(2)->isNull(); } +IfcText IfcDocumentInformation::Description() { return *entity->getArgument(2); } +bool IfcDocumentInformation::hasDocumentReferences() { return !entity->getArgument(3)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcDocumentInformation::DocumentReferences() { RETURN_AS_LIST(IfcDocumentReference,3) } +bool IfcDocumentInformation::hasPurpose() { return !entity->getArgument(4)->isNull(); } +IfcText IfcDocumentInformation::Purpose() { return *entity->getArgument(4); } +bool IfcDocumentInformation::hasIntendedUse() { return !entity->getArgument(5)->isNull(); } +IfcText IfcDocumentInformation::IntendedUse() { return *entity->getArgument(5); } +bool IfcDocumentInformation::hasScope() { return !entity->getArgument(6)->isNull(); } +IfcText IfcDocumentInformation::Scope() { return *entity->getArgument(6); } +bool IfcDocumentInformation::hasRevision() { return !entity->getArgument(7)->isNull(); } +IfcLabel IfcDocumentInformation::Revision() { return *entity->getArgument(7); } +bool IfcDocumentInformation::hasDocumentOwner() { return !entity->getArgument(8)->isNull(); } +IfcActorSelect IfcDocumentInformation::DocumentOwner() { return *entity->getArgument(8); } +bool IfcDocumentInformation::hasEditors() { return !entity->getArgument(9)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcDocumentInformation::Editors() { RETURN_AS_LIST(IfcAbstractSelect,9) } +bool IfcDocumentInformation::hasCreationTime() { return !entity->getArgument(10)->isNull(); } +SHARED_PTR IfcDocumentInformation::CreationTime() { return reinterpret_pointer_cast(*entity->getArgument(10)); } +bool IfcDocumentInformation::hasLastRevisionTime() { return !entity->getArgument(11)->isNull(); } +SHARED_PTR IfcDocumentInformation::LastRevisionTime() { return reinterpret_pointer_cast(*entity->getArgument(11)); } +bool IfcDocumentInformation::hasElectronicFormat() { return !entity->getArgument(12)->isNull(); } +SHARED_PTR IfcDocumentInformation::ElectronicFormat() { return reinterpret_pointer_cast(*entity->getArgument(12)); } +bool IfcDocumentInformation::hasValidFrom() { return !entity->getArgument(13)->isNull(); } +SHARED_PTR IfcDocumentInformation::ValidFrom() { return reinterpret_pointer_cast(*entity->getArgument(13)); } +bool IfcDocumentInformation::hasValidUntil() { return !entity->getArgument(14)->isNull(); } +SHARED_PTR IfcDocumentInformation::ValidUntil() { return reinterpret_pointer_cast(*entity->getArgument(14)); } +bool IfcDocumentInformation::hasConfidentiality() { return !entity->getArgument(15)->isNull(); } +IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum IfcDocumentInformation::Confidentiality() { return IfcDocumentConfidentialityEnum::FromString(*entity->getArgument(15)); } +bool IfcDocumentInformation::hasStatus() { return !entity->getArgument(16)->isNull(); } +IfcDocumentStatusEnum::IfcDocumentStatusEnum IfcDocumentInformation::Status() { return IfcDocumentStatusEnum::FromString(*entity->getArgument(16)); } +IfcDocumentInformationRelationship::list IfcDocumentInformation::IsPointedTo() { RETURN_INVERSE(IfcDocumentInformationRelationship) } +IfcDocumentInformationRelationship::list IfcDocumentInformation::IsPointer() { RETURN_INVERSE(IfcDocumentInformationRelationship) } +bool IfcDocumentInformation::is(Type::Enum v) { return v == Type::IfcDocumentInformation; } +Type::Enum IfcDocumentInformation::type() { return Type::IfcDocumentInformation; } +Type::Enum IfcDocumentInformation::Class() { return Type::IfcDocumentInformation; } +IfcDocumentInformation::IfcDocumentInformation(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentInformation)) throw; entity = e; } +// IfcDocumentInformationRelationship +SHARED_PTR IfcDocumentInformationRelationship::RelatingDocument() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR< IfcTemplatedEntityList > IfcDocumentInformationRelationship::RelatedDocuments() { RETURN_AS_LIST(IfcDocumentInformation,1) } +bool IfcDocumentInformationRelationship::hasRelationshipType() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcDocumentInformationRelationship::RelationshipType() { return *entity->getArgument(2); } +bool IfcDocumentInformationRelationship::is(Type::Enum v) { return v == Type::IfcDocumentInformationRelationship; } +Type::Enum IfcDocumentInformationRelationship::type() { return Type::IfcDocumentInformationRelationship; } +Type::Enum IfcDocumentInformationRelationship::Class() { return Type::IfcDocumentInformationRelationship; } +IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentInformationRelationship)) throw; entity = e; } +// IfcDocumentReference +IfcDocumentInformation::list IfcDocumentReference::ReferenceToDocument() { RETURN_INVERSE(IfcDocumentInformation) } +bool IfcDocumentReference::is(Type::Enum v) { return v == Type::IfcDocumentReference || IfcExternalReference::is(v); } +Type::Enum IfcDocumentReference::type() { return Type::IfcDocumentReference; } +Type::Enum IfcDocumentReference::Class() { return Type::IfcDocumentReference; } +IfcDocumentReference::IfcDocumentReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentReference)) throw; entity = e; } +// IfcDoor +bool IfcDoor::hasOverallHeight() { return !entity->getArgument(8)->isNull(); } +IfcPositiveLengthMeasure IfcDoor::OverallHeight() { return *entity->getArgument(8); } +bool IfcDoor::hasOverallWidth() { return !entity->getArgument(9)->isNull(); } +IfcPositiveLengthMeasure IfcDoor::OverallWidth() { return *entity->getArgument(9); } +bool IfcDoor::is(Type::Enum v) { return v == Type::IfcDoor || IfcBuildingElement::is(v); } +Type::Enum IfcDoor::type() { return Type::IfcDoor; } +Type::Enum IfcDoor::Class() { return Type::IfcDoor; } +IfcDoor::IfcDoor(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoor)) throw; entity = e; } +// IfcDoorLiningProperties +bool IfcDoorLiningProperties::hasLiningDepth() { return !entity->getArgument(4)->isNull(); } +IfcPositiveLengthMeasure IfcDoorLiningProperties::LiningDepth() { return *entity->getArgument(4); } +bool IfcDoorLiningProperties::hasLiningThickness() { return !entity->getArgument(5)->isNull(); } +IfcPositiveLengthMeasure IfcDoorLiningProperties::LiningThickness() { return *entity->getArgument(5); } +bool IfcDoorLiningProperties::hasThresholdDepth() { return !entity->getArgument(6)->isNull(); } +IfcPositiveLengthMeasure IfcDoorLiningProperties::ThresholdDepth() { return *entity->getArgument(6); } +bool IfcDoorLiningProperties::hasThresholdThickness() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcDoorLiningProperties::ThresholdThickness() { return *entity->getArgument(7); } +bool IfcDoorLiningProperties::hasTransomThickness() { return !entity->getArgument(8)->isNull(); } +IfcPositiveLengthMeasure IfcDoorLiningProperties::TransomThickness() { return *entity->getArgument(8); } +bool IfcDoorLiningProperties::hasTransomOffset() { return !entity->getArgument(9)->isNull(); } +IfcLengthMeasure IfcDoorLiningProperties::TransomOffset() { return *entity->getArgument(9); } +bool IfcDoorLiningProperties::hasLiningOffset() { return !entity->getArgument(10)->isNull(); } +IfcLengthMeasure IfcDoorLiningProperties::LiningOffset() { return *entity->getArgument(10); } +bool IfcDoorLiningProperties::hasThresholdOffset() { return !entity->getArgument(11)->isNull(); } +IfcLengthMeasure IfcDoorLiningProperties::ThresholdOffset() { return *entity->getArgument(11); } +bool IfcDoorLiningProperties::hasCasingThickness() { return !entity->getArgument(12)->isNull(); } +IfcPositiveLengthMeasure IfcDoorLiningProperties::CasingThickness() { return *entity->getArgument(12); } +bool IfcDoorLiningProperties::hasCasingDepth() { return !entity->getArgument(13)->isNull(); } +IfcPositiveLengthMeasure IfcDoorLiningProperties::CasingDepth() { return *entity->getArgument(13); } +bool IfcDoorLiningProperties::hasShapeAspectStyle() { return !entity->getArgument(14)->isNull(); } +SHARED_PTR IfcDoorLiningProperties::ShapeAspectStyle() { return reinterpret_pointer_cast(*entity->getArgument(14)); } +bool IfcDoorLiningProperties::is(Type::Enum v) { return v == Type::IfcDoorLiningProperties || IfcPropertySetDefinition::is(v); } +Type::Enum IfcDoorLiningProperties::type() { return Type::IfcDoorLiningProperties; } +Type::Enum IfcDoorLiningProperties::Class() { return Type::IfcDoorLiningProperties; } +IfcDoorLiningProperties::IfcDoorLiningProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoorLiningProperties)) throw; entity = e; } +// IfcDoorPanelProperties +bool IfcDoorPanelProperties::hasPanelDepth() { return !entity->getArgument(4)->isNull(); } +IfcPositiveLengthMeasure IfcDoorPanelProperties::PanelDepth() { return *entity->getArgument(4); } +IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum IfcDoorPanelProperties::PanelOperation() { return IfcDoorPanelOperationEnum::FromString(*entity->getArgument(5)); } +bool IfcDoorPanelProperties::hasPanelWidth() { return !entity->getArgument(6)->isNull(); } +IfcNormalisedRatioMeasure IfcDoorPanelProperties::PanelWidth() { return *entity->getArgument(6); } +IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum IfcDoorPanelProperties::PanelPosition() { return IfcDoorPanelPositionEnum::FromString(*entity->getArgument(7)); } +bool IfcDoorPanelProperties::hasShapeAspectStyle() { return !entity->getArgument(8)->isNull(); } +SHARED_PTR IfcDoorPanelProperties::ShapeAspectStyle() { return reinterpret_pointer_cast(*entity->getArgument(8)); } +bool IfcDoorPanelProperties::is(Type::Enum v) { return v == Type::IfcDoorPanelProperties || IfcPropertySetDefinition::is(v); } +Type::Enum IfcDoorPanelProperties::type() { return Type::IfcDoorPanelProperties; } +Type::Enum IfcDoorPanelProperties::Class() { return Type::IfcDoorPanelProperties; } +IfcDoorPanelProperties::IfcDoorPanelProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoorPanelProperties)) throw; entity = e; } +// IfcDoorStyle +IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum IfcDoorStyle::OperationType() { return IfcDoorStyleOperationEnum::FromString(*entity->getArgument(8)); } +IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum IfcDoorStyle::ConstructionType() { return IfcDoorStyleConstructionEnum::FromString(*entity->getArgument(9)); } +bool IfcDoorStyle::ParameterTakesPrecedence() { return *entity->getArgument(10); } +bool IfcDoorStyle::Sizeable() { return *entity->getArgument(11); } +bool IfcDoorStyle::is(Type::Enum v) { return v == Type::IfcDoorStyle || IfcTypeProduct::is(v); } +Type::Enum IfcDoorStyle::type() { return Type::IfcDoorStyle; } +Type::Enum IfcDoorStyle::Class() { return Type::IfcDoorStyle; } +IfcDoorStyle::IfcDoorStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoorStyle)) throw; entity = e; } +// IfcDraughtingCallout +SHARED_PTR< IfcTemplatedEntityList > IfcDraughtingCallout::Contents() { RETURN_AS_LIST(IfcAbstractSelect,0) } +IfcDraughtingCalloutRelationship::list IfcDraughtingCallout::IsRelatedFromCallout() { RETURN_INVERSE(IfcDraughtingCalloutRelationship) } +IfcDraughtingCalloutRelationship::list IfcDraughtingCallout::IsRelatedToCallout() { RETURN_INVERSE(IfcDraughtingCalloutRelationship) } +bool IfcDraughtingCallout::is(Type::Enum v) { return v == Type::IfcDraughtingCallout || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcDraughtingCallout::type() { return Type::IfcDraughtingCallout; } +Type::Enum IfcDraughtingCallout::Class() { return Type::IfcDraughtingCallout; } +IfcDraughtingCallout::IfcDraughtingCallout(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingCallout)) throw; entity = e; } +// IfcDraughtingCalloutRelationship +bool IfcDraughtingCalloutRelationship::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcDraughtingCalloutRelationship::Name() { return *entity->getArgument(0); } +bool IfcDraughtingCalloutRelationship::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcDraughtingCalloutRelationship::Description() { return *entity->getArgument(1); } +SHARED_PTR IfcDraughtingCalloutRelationship::RelatingDraughtingCallout() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +SHARED_PTR IfcDraughtingCalloutRelationship::RelatedDraughtingCallout() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcDraughtingCalloutRelationship::is(Type::Enum v) { return v == Type::IfcDraughtingCalloutRelationship; } +Type::Enum IfcDraughtingCalloutRelationship::type() { return Type::IfcDraughtingCalloutRelationship; } +Type::Enum IfcDraughtingCalloutRelationship::Class() { return Type::IfcDraughtingCalloutRelationship; } +IfcDraughtingCalloutRelationship::IfcDraughtingCalloutRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingCalloutRelationship)) throw; entity = e; } +// IfcDraughtingPreDefinedColour +bool IfcDraughtingPreDefinedColour::is(Type::Enum v) { return v == Type::IfcDraughtingPreDefinedColour || IfcPreDefinedColour::is(v); } +Type::Enum IfcDraughtingPreDefinedColour::type() { return Type::IfcDraughtingPreDefinedColour; } +Type::Enum IfcDraughtingPreDefinedColour::Class() { return Type::IfcDraughtingPreDefinedColour; } +IfcDraughtingPreDefinedColour::IfcDraughtingPreDefinedColour(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingPreDefinedColour)) throw; entity = e; } +// IfcDraughtingPreDefinedCurveFont +bool IfcDraughtingPreDefinedCurveFont::is(Type::Enum v) { return v == Type::IfcDraughtingPreDefinedCurveFont || IfcPreDefinedCurveFont::is(v); } +Type::Enum IfcDraughtingPreDefinedCurveFont::type() { return Type::IfcDraughtingPreDefinedCurveFont; } +Type::Enum IfcDraughtingPreDefinedCurveFont::Class() { return Type::IfcDraughtingPreDefinedCurveFont; } +IfcDraughtingPreDefinedCurveFont::IfcDraughtingPreDefinedCurveFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingPreDefinedCurveFont)) throw; entity = e; } +// IfcDraughtingPreDefinedTextFont +bool IfcDraughtingPreDefinedTextFont::is(Type::Enum v) { return v == Type::IfcDraughtingPreDefinedTextFont || IfcPreDefinedTextFont::is(v); } +Type::Enum IfcDraughtingPreDefinedTextFont::type() { return Type::IfcDraughtingPreDefinedTextFont; } +Type::Enum IfcDraughtingPreDefinedTextFont::Class() { return Type::IfcDraughtingPreDefinedTextFont; } +IfcDraughtingPreDefinedTextFont::IfcDraughtingPreDefinedTextFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingPreDefinedTextFont)) throw; entity = e; } +// IfcDuctFittingType +IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum IfcDuctFittingType::PredefinedType() { return IfcDuctFittingTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcDuctFittingType::is(Type::Enum v) { return v == Type::IfcDuctFittingType || IfcFlowFittingType::is(v); } +Type::Enum IfcDuctFittingType::type() { return Type::IfcDuctFittingType; } +Type::Enum IfcDuctFittingType::Class() { return Type::IfcDuctFittingType; } +IfcDuctFittingType::IfcDuctFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDuctFittingType)) throw; entity = e; } +// IfcDuctSegmentType +IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum IfcDuctSegmentType::PredefinedType() { return IfcDuctSegmentTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcDuctSegmentType::is(Type::Enum v) { return v == Type::IfcDuctSegmentType || IfcFlowSegmentType::is(v); } +Type::Enum IfcDuctSegmentType::type() { return Type::IfcDuctSegmentType; } +Type::Enum IfcDuctSegmentType::Class() { return Type::IfcDuctSegmentType; } +IfcDuctSegmentType::IfcDuctSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDuctSegmentType)) throw; entity = e; } +// IfcDuctSilencerType +IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum IfcDuctSilencerType::PredefinedType() { return IfcDuctSilencerTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcDuctSilencerType::is(Type::Enum v) { return v == Type::IfcDuctSilencerType || IfcFlowTreatmentDeviceType::is(v); } +Type::Enum IfcDuctSilencerType::type() { return Type::IfcDuctSilencerType; } +Type::Enum IfcDuctSilencerType::Class() { return Type::IfcDuctSilencerType; } +IfcDuctSilencerType::IfcDuctSilencerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDuctSilencerType)) throw; entity = e; } +// IfcEdge +SHARED_PTR IfcEdge::EdgeStart() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcEdge::EdgeEnd() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcEdge::is(Type::Enum v) { return v == Type::IfcEdge || IfcTopologicalRepresentationItem::is(v); } +Type::Enum IfcEdge::type() { return Type::IfcEdge; } +Type::Enum IfcEdge::Class() { return Type::IfcEdge; } +IfcEdge::IfcEdge(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdge)) throw; entity = e; } +// IfcEdgeCurve +SHARED_PTR IfcEdgeCurve::EdgeGeometry() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcEdgeCurve::SameSense() { return *entity->getArgument(3); } +bool IfcEdgeCurve::is(Type::Enum v) { return v == Type::IfcEdgeCurve || IfcEdge::is(v); } +Type::Enum IfcEdgeCurve::type() { return Type::IfcEdgeCurve; } +Type::Enum IfcEdgeCurve::Class() { return Type::IfcEdgeCurve; } +IfcEdgeCurve::IfcEdgeCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdgeCurve)) throw; entity = e; } +// IfcEdgeFeature +bool IfcEdgeFeature::hasFeatureLength() { return !entity->getArgument(8)->isNull(); } +IfcPositiveLengthMeasure IfcEdgeFeature::FeatureLength() { return *entity->getArgument(8); } +bool IfcEdgeFeature::is(Type::Enum v) { return v == Type::IfcEdgeFeature || IfcFeatureElementSubtraction::is(v); } +Type::Enum IfcEdgeFeature::type() { return Type::IfcEdgeFeature; } +Type::Enum IfcEdgeFeature::Class() { return Type::IfcEdgeFeature; } +IfcEdgeFeature::IfcEdgeFeature(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdgeFeature)) throw; entity = e; } +// IfcEdgeLoop +SHARED_PTR< IfcTemplatedEntityList > IfcEdgeLoop::EdgeList() { RETURN_AS_LIST(IfcOrientedEdge,0) } +bool IfcEdgeLoop::is(Type::Enum v) { return v == Type::IfcEdgeLoop || IfcLoop::is(v); } +Type::Enum IfcEdgeLoop::type() { return Type::IfcEdgeLoop; } +Type::Enum IfcEdgeLoop::Class() { return Type::IfcEdgeLoop; } +IfcEdgeLoop::IfcEdgeLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdgeLoop)) throw; entity = e; } +// IfcElectricApplianceType +IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum IfcElectricApplianceType::PredefinedType() { return IfcElectricApplianceTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcElectricApplianceType::is(Type::Enum v) { return v == Type::IfcElectricApplianceType || IfcFlowTerminalType::is(v); } +Type::Enum IfcElectricApplianceType::type() { return Type::IfcElectricApplianceType; } +Type::Enum IfcElectricApplianceType::Class() { return Type::IfcElectricApplianceType; } +IfcElectricApplianceType::IfcElectricApplianceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricApplianceType)) throw; entity = e; } +// IfcElectricDistributionPoint +IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum IfcElectricDistributionPoint::DistributionPointFunction() { return IfcElectricDistributionPointFunctionEnum::FromString(*entity->getArgument(8)); } +bool IfcElectricDistributionPoint::hasUserDefinedFunction() { return !entity->getArgument(9)->isNull(); } +IfcLabel IfcElectricDistributionPoint::UserDefinedFunction() { return *entity->getArgument(9); } +bool IfcElectricDistributionPoint::is(Type::Enum v) { return v == Type::IfcElectricDistributionPoint || IfcFlowController::is(v); } +Type::Enum IfcElectricDistributionPoint::type() { return Type::IfcElectricDistributionPoint; } +Type::Enum IfcElectricDistributionPoint::Class() { return Type::IfcElectricDistributionPoint; } +IfcElectricDistributionPoint::IfcElectricDistributionPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricDistributionPoint)) throw; entity = e; } +// IfcElectricFlowStorageDeviceType +IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum IfcElectricFlowStorageDeviceType::PredefinedType() { return IfcElectricFlowStorageDeviceTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcElectricFlowStorageDeviceType::is(Type::Enum v) { return v == Type::IfcElectricFlowStorageDeviceType || IfcFlowStorageDeviceType::is(v); } +Type::Enum IfcElectricFlowStorageDeviceType::type() { return Type::IfcElectricFlowStorageDeviceType; } +Type::Enum IfcElectricFlowStorageDeviceType::Class() { return Type::IfcElectricFlowStorageDeviceType; } +IfcElectricFlowStorageDeviceType::IfcElectricFlowStorageDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricFlowStorageDeviceType)) throw; entity = e; } +// IfcElectricGeneratorType +IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum IfcElectricGeneratorType::PredefinedType() { return IfcElectricGeneratorTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcElectricGeneratorType::is(Type::Enum v) { return v == Type::IfcElectricGeneratorType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcElectricGeneratorType::type() { return Type::IfcElectricGeneratorType; } +Type::Enum IfcElectricGeneratorType::Class() { return Type::IfcElectricGeneratorType; } +IfcElectricGeneratorType::IfcElectricGeneratorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricGeneratorType)) throw; entity = e; } +// IfcElectricHeaterType +IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum IfcElectricHeaterType::PredefinedType() { return IfcElectricHeaterTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcElectricHeaterType::is(Type::Enum v) { return v == Type::IfcElectricHeaterType || IfcFlowTerminalType::is(v); } +Type::Enum IfcElectricHeaterType::type() { return Type::IfcElectricHeaterType; } +Type::Enum IfcElectricHeaterType::Class() { return Type::IfcElectricHeaterType; } +IfcElectricHeaterType::IfcElectricHeaterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricHeaterType)) throw; entity = e; } +// IfcElectricMotorType +IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum IfcElectricMotorType::PredefinedType() { return IfcElectricMotorTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcElectricMotorType::is(Type::Enum v) { return v == Type::IfcElectricMotorType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcElectricMotorType::type() { return Type::IfcElectricMotorType; } +Type::Enum IfcElectricMotorType::Class() { return Type::IfcElectricMotorType; } +IfcElectricMotorType::IfcElectricMotorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricMotorType)) throw; entity = e; } +// IfcElectricTimeControlType +IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum IfcElectricTimeControlType::PredefinedType() { return IfcElectricTimeControlTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcElectricTimeControlType::is(Type::Enum v) { return v == Type::IfcElectricTimeControlType || IfcFlowControllerType::is(v); } +Type::Enum IfcElectricTimeControlType::type() { return Type::IfcElectricTimeControlType; } +Type::Enum IfcElectricTimeControlType::Class() { return Type::IfcElectricTimeControlType; } +IfcElectricTimeControlType::IfcElectricTimeControlType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricTimeControlType)) throw; entity = e; } +// IfcElectricalBaseProperties +bool IfcElectricalBaseProperties::hasElectricCurrentType() { return !entity->getArgument(6)->isNull(); } +IfcElectricCurrentEnum::IfcElectricCurrentEnum IfcElectricalBaseProperties::ElectricCurrentType() { return IfcElectricCurrentEnum::FromString(*entity->getArgument(6)); } +IfcElectricVoltageMeasure IfcElectricalBaseProperties::InputVoltage() { return *entity->getArgument(7); } +IfcFrequencyMeasure IfcElectricalBaseProperties::InputFrequency() { return *entity->getArgument(8); } +bool IfcElectricalBaseProperties::hasFullLoadCurrent() { return !entity->getArgument(9)->isNull(); } +IfcElectricCurrentMeasure IfcElectricalBaseProperties::FullLoadCurrent() { return *entity->getArgument(9); } +bool IfcElectricalBaseProperties::hasMinimumCircuitCurrent() { return !entity->getArgument(10)->isNull(); } +IfcElectricCurrentMeasure IfcElectricalBaseProperties::MinimumCircuitCurrent() { return *entity->getArgument(10); } +bool IfcElectricalBaseProperties::hasMaximumPowerInput() { return !entity->getArgument(11)->isNull(); } +IfcPowerMeasure IfcElectricalBaseProperties::MaximumPowerInput() { return *entity->getArgument(11); } +bool IfcElectricalBaseProperties::hasRatedPowerInput() { return !entity->getArgument(12)->isNull(); } +IfcPowerMeasure IfcElectricalBaseProperties::RatedPowerInput() { return *entity->getArgument(12); } +int IfcElectricalBaseProperties::InputPhase() { return *entity->getArgument(13); } +bool IfcElectricalBaseProperties::is(Type::Enum v) { return v == Type::IfcElectricalBaseProperties || IfcEnergyProperties::is(v); } +Type::Enum IfcElectricalBaseProperties::type() { return Type::IfcElectricalBaseProperties; } +Type::Enum IfcElectricalBaseProperties::Class() { return Type::IfcElectricalBaseProperties; } +IfcElectricalBaseProperties::IfcElectricalBaseProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricalBaseProperties)) throw; entity = e; } +// IfcElectricalCircuit +bool IfcElectricalCircuit::is(Type::Enum v) { return v == Type::IfcElectricalCircuit || IfcSystem::is(v); } +Type::Enum IfcElectricalCircuit::type() { return Type::IfcElectricalCircuit; } +Type::Enum IfcElectricalCircuit::Class() { return Type::IfcElectricalCircuit; } +IfcElectricalCircuit::IfcElectricalCircuit(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricalCircuit)) throw; entity = e; } +// IfcElectricalElement +bool IfcElectricalElement::is(Type::Enum v) { return v == Type::IfcElectricalElement || IfcElement::is(v); } +Type::Enum IfcElectricalElement::type() { return Type::IfcElectricalElement; } +Type::Enum IfcElectricalElement::Class() { return Type::IfcElectricalElement; } +IfcElectricalElement::IfcElectricalElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricalElement)) throw; entity = e; } +// IfcElement +bool IfcElement::hasTag() { return !entity->getArgument(7)->isNull(); } +IfcIdentifier IfcElement::Tag() { return *entity->getArgument(7); } +IfcRelConnectsStructuralElement::list IfcElement::HasStructuralMember() { RETURN_INVERSE(IfcRelConnectsStructuralElement) } +IfcRelFillsElement::list IfcElement::FillsVoids() { RETURN_INVERSE(IfcRelFillsElement) } +IfcRelConnectsElements::list IfcElement::ConnectedTo() { RETURN_INVERSE(IfcRelConnectsElements) } +IfcRelCoversBldgElements::list IfcElement::HasCoverings() { RETURN_INVERSE(IfcRelCoversBldgElements) } +IfcRelProjectsElement::list IfcElement::HasProjections() { RETURN_INVERSE(IfcRelProjectsElement) } +IfcRelReferencedInSpatialStructure::list IfcElement::ReferencedInStructures() { RETURN_INVERSE(IfcRelReferencedInSpatialStructure) } +IfcRelConnectsPortToElement::list IfcElement::HasPorts() { RETURN_INVERSE(IfcRelConnectsPortToElement) } +IfcRelVoidsElement::list IfcElement::HasOpenings() { RETURN_INVERSE(IfcRelVoidsElement) } +IfcRelConnectsWithRealizingElements::list IfcElement::IsConnectionRealization() { RETURN_INVERSE(IfcRelConnectsWithRealizingElements) } +IfcRelSpaceBoundary::list IfcElement::ProvidesBoundaries() { RETURN_INVERSE(IfcRelSpaceBoundary) } +IfcRelConnectsElements::list IfcElement::ConnectedFrom() { RETURN_INVERSE(IfcRelConnectsElements) } +IfcRelContainedInSpatialStructure::list IfcElement::ContainedInStructure() { RETURN_INVERSE(IfcRelContainedInSpatialStructure) } +bool IfcElement::is(Type::Enum v) { return v == Type::IfcElement || IfcProduct::is(v); } +Type::Enum IfcElement::type() { return Type::IfcElement; } +Type::Enum IfcElement::Class() { return Type::IfcElement; } +IfcElement::IfcElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcElement)) throw; entity = e; } +// IfcElementAssembly +bool IfcElementAssembly::hasAssemblyPlace() { return !entity->getArgument(8)->isNull(); } +IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum IfcElementAssembly::AssemblyPlace() { return IfcAssemblyPlaceEnum::FromString(*entity->getArgument(8)); } +IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum IfcElementAssembly::PredefinedType() { return IfcElementAssemblyTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcElementAssembly::is(Type::Enum v) { return v == Type::IfcElementAssembly || IfcElement::is(v); } +Type::Enum IfcElementAssembly::type() { return Type::IfcElementAssembly; } +Type::Enum IfcElementAssembly::Class() { return Type::IfcElementAssembly; } +IfcElementAssembly::IfcElementAssembly(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementAssembly)) throw; entity = e; } +// IfcElementComponent +bool IfcElementComponent::is(Type::Enum v) { return v == Type::IfcElementComponent || IfcElement::is(v); } +Type::Enum IfcElementComponent::type() { return Type::IfcElementComponent; } +Type::Enum IfcElementComponent::Class() { return Type::IfcElementComponent; } +IfcElementComponent::IfcElementComponent(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementComponent)) throw; entity = e; } +// IfcElementComponentType +bool IfcElementComponentType::is(Type::Enum v) { return v == Type::IfcElementComponentType || IfcElementType::is(v); } +Type::Enum IfcElementComponentType::type() { return Type::IfcElementComponentType; } +Type::Enum IfcElementComponentType::Class() { return Type::IfcElementComponentType; } +IfcElementComponentType::IfcElementComponentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementComponentType)) throw; entity = e; } +// IfcElementQuantity +bool IfcElementQuantity::hasMethodOfMeasurement() { return !entity->getArgument(4)->isNull(); } +IfcLabel IfcElementQuantity::MethodOfMeasurement() { return *entity->getArgument(4); } +SHARED_PTR< IfcTemplatedEntityList > IfcElementQuantity::Quantities() { RETURN_AS_LIST(IfcPhysicalQuantity,5) } +bool IfcElementQuantity::is(Type::Enum v) { return v == Type::IfcElementQuantity || IfcPropertySetDefinition::is(v); } +Type::Enum IfcElementQuantity::type() { return Type::IfcElementQuantity; } +Type::Enum IfcElementQuantity::Class() { return Type::IfcElementQuantity; } +IfcElementQuantity::IfcElementQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementQuantity)) throw; entity = e; } +// IfcElementType +bool IfcElementType::hasElementType() { return !entity->getArgument(8)->isNull(); } +IfcLabel IfcElementType::ElementType() { return *entity->getArgument(8); } +bool IfcElementType::is(Type::Enum v) { return v == Type::IfcElementType || IfcTypeProduct::is(v); } +Type::Enum IfcElementType::type() { return Type::IfcElementType; } +Type::Enum IfcElementType::Class() { return Type::IfcElementType; } +IfcElementType::IfcElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementType)) throw; entity = e; } +// IfcElementarySurface +SHARED_PTR IfcElementarySurface::Position() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcElementarySurface::is(Type::Enum v) { return v == Type::IfcElementarySurface || IfcSurface::is(v); } +Type::Enum IfcElementarySurface::type() { return Type::IfcElementarySurface; } +Type::Enum IfcElementarySurface::Class() { return Type::IfcElementarySurface; } +IfcElementarySurface::IfcElementarySurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementarySurface)) throw; entity = e; } +// IfcEllipse +IfcPositiveLengthMeasure IfcEllipse::SemiAxis1() { return *entity->getArgument(1); } +IfcPositiveLengthMeasure IfcEllipse::SemiAxis2() { return *entity->getArgument(2); } +bool IfcEllipse::is(Type::Enum v) { return v == Type::IfcEllipse || IfcConic::is(v); } +Type::Enum IfcEllipse::type() { return Type::IfcEllipse; } +Type::Enum IfcEllipse::Class() { return Type::IfcEllipse; } +IfcEllipse::IfcEllipse(IfcAbstractEntityPtr e) { if (!is(Type::IfcEllipse)) throw; entity = e; } +// IfcEllipseProfileDef +IfcPositiveLengthMeasure IfcEllipseProfileDef::SemiAxis1() { return *entity->getArgument(3); } +IfcPositiveLengthMeasure IfcEllipseProfileDef::SemiAxis2() { return *entity->getArgument(4); } +bool IfcEllipseProfileDef::is(Type::Enum v) { return v == Type::IfcEllipseProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcEllipseProfileDef::type() { return Type::IfcEllipseProfileDef; } +Type::Enum IfcEllipseProfileDef::Class() { return Type::IfcEllipseProfileDef; } +IfcEllipseProfileDef::IfcEllipseProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcEllipseProfileDef)) throw; entity = e; } +// IfcEnergyConversionDevice +bool IfcEnergyConversionDevice::is(Type::Enum v) { return v == Type::IfcEnergyConversionDevice || IfcDistributionFlowElement::is(v); } +Type::Enum IfcEnergyConversionDevice::type() { return Type::IfcEnergyConversionDevice; } +Type::Enum IfcEnergyConversionDevice::Class() { return Type::IfcEnergyConversionDevice; } +IfcEnergyConversionDevice::IfcEnergyConversionDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnergyConversionDevice)) throw; entity = e; } +// IfcEnergyConversionDeviceType +bool IfcEnergyConversionDeviceType::is(Type::Enum v) { return v == Type::IfcEnergyConversionDeviceType || IfcDistributionFlowElementType::is(v); } +Type::Enum IfcEnergyConversionDeviceType::type() { return Type::IfcEnergyConversionDeviceType; } +Type::Enum IfcEnergyConversionDeviceType::Class() { return Type::IfcEnergyConversionDeviceType; } +IfcEnergyConversionDeviceType::IfcEnergyConversionDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnergyConversionDeviceType)) throw; entity = e; } +// IfcEnergyProperties +bool IfcEnergyProperties::hasEnergySequence() { return !entity->getArgument(4)->isNull(); } +IfcEnergySequenceEnum::IfcEnergySequenceEnum IfcEnergyProperties::EnergySequence() { return IfcEnergySequenceEnum::FromString(*entity->getArgument(4)); } +bool IfcEnergyProperties::hasUserDefinedEnergySequence() { return !entity->getArgument(5)->isNull(); } +IfcLabel IfcEnergyProperties::UserDefinedEnergySequence() { return *entity->getArgument(5); } +bool IfcEnergyProperties::is(Type::Enum v) { return v == Type::IfcEnergyProperties || IfcPropertySetDefinition::is(v); } +Type::Enum IfcEnergyProperties::type() { return Type::IfcEnergyProperties; } +Type::Enum IfcEnergyProperties::Class() { return Type::IfcEnergyProperties; } +IfcEnergyProperties::IfcEnergyProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnergyProperties)) throw; entity = e; } +// IfcEnvironmentalImpactValue +IfcLabel IfcEnvironmentalImpactValue::ImpactType() { return *entity->getArgument(6); } +IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum IfcEnvironmentalImpactValue::Category() { return IfcEnvironmentalImpactCategoryEnum::FromString(*entity->getArgument(7)); } +bool IfcEnvironmentalImpactValue::hasUserDefinedCategory() { return !entity->getArgument(8)->isNull(); } +IfcLabel IfcEnvironmentalImpactValue::UserDefinedCategory() { return *entity->getArgument(8); } +bool IfcEnvironmentalImpactValue::is(Type::Enum v) { return v == Type::IfcEnvironmentalImpactValue || IfcAppliedValue::is(v); } +Type::Enum IfcEnvironmentalImpactValue::type() { return Type::IfcEnvironmentalImpactValue; } +Type::Enum IfcEnvironmentalImpactValue::Class() { return Type::IfcEnvironmentalImpactValue; } +IfcEnvironmentalImpactValue::IfcEnvironmentalImpactValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnvironmentalImpactValue)) throw; entity = e; } +// IfcEquipmentElement +bool IfcEquipmentElement::is(Type::Enum v) { return v == Type::IfcEquipmentElement || IfcElement::is(v); } +Type::Enum IfcEquipmentElement::type() { return Type::IfcEquipmentElement; } +Type::Enum IfcEquipmentElement::Class() { return Type::IfcEquipmentElement; } +IfcEquipmentElement::IfcEquipmentElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcEquipmentElement)) throw; entity = e; } +// IfcEquipmentStandard +bool IfcEquipmentStandard::is(Type::Enum v) { return v == Type::IfcEquipmentStandard || IfcControl::is(v); } +Type::Enum IfcEquipmentStandard::type() { return Type::IfcEquipmentStandard; } +Type::Enum IfcEquipmentStandard::Class() { return Type::IfcEquipmentStandard; } +IfcEquipmentStandard::IfcEquipmentStandard(IfcAbstractEntityPtr e) { if (!is(Type::IfcEquipmentStandard)) throw; entity = e; } +// IfcEvaporativeCoolerType +IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum IfcEvaporativeCoolerType::PredefinedType() { return IfcEvaporativeCoolerTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcEvaporativeCoolerType::is(Type::Enum v) { return v == Type::IfcEvaporativeCoolerType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcEvaporativeCoolerType::type() { return Type::IfcEvaporativeCoolerType; } +Type::Enum IfcEvaporativeCoolerType::Class() { return Type::IfcEvaporativeCoolerType; } +IfcEvaporativeCoolerType::IfcEvaporativeCoolerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcEvaporativeCoolerType)) throw; entity = e; } +// IfcEvaporatorType +IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum IfcEvaporatorType::PredefinedType() { return IfcEvaporatorTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcEvaporatorType::is(Type::Enum v) { return v == Type::IfcEvaporatorType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcEvaporatorType::type() { return Type::IfcEvaporatorType; } +Type::Enum IfcEvaporatorType::Class() { return Type::IfcEvaporatorType; } +IfcEvaporatorType::IfcEvaporatorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcEvaporatorType)) throw; entity = e; } +// IfcExtendedMaterialProperties +SHARED_PTR< IfcTemplatedEntityList > IfcExtendedMaterialProperties::ExtendedProperties() { RETURN_AS_LIST(IfcProperty,1) } +bool IfcExtendedMaterialProperties::hasDescription() { return !entity->getArgument(2)->isNull(); } +IfcText IfcExtendedMaterialProperties::Description() { return *entity->getArgument(2); } +IfcLabel IfcExtendedMaterialProperties::Name() { return *entity->getArgument(3); } +bool IfcExtendedMaterialProperties::is(Type::Enum v) { return v == Type::IfcExtendedMaterialProperties || IfcMaterialProperties::is(v); } +Type::Enum IfcExtendedMaterialProperties::type() { return Type::IfcExtendedMaterialProperties; } +Type::Enum IfcExtendedMaterialProperties::Class() { return Type::IfcExtendedMaterialProperties; } +IfcExtendedMaterialProperties::IfcExtendedMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcExtendedMaterialProperties)) throw; entity = e; } +// IfcExternalReference +bool IfcExternalReference::hasLocation() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcExternalReference::Location() { return *entity->getArgument(0); } +bool IfcExternalReference::hasItemReference() { return !entity->getArgument(1)->isNull(); } +IfcIdentifier IfcExternalReference::ItemReference() { return *entity->getArgument(1); } +bool IfcExternalReference::hasName() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcExternalReference::Name() { return *entity->getArgument(2); } +bool IfcExternalReference::is(Type::Enum v) { return v == Type::IfcExternalReference; } +Type::Enum IfcExternalReference::type() { return Type::IfcExternalReference; } +Type::Enum IfcExternalReference::Class() { return Type::IfcExternalReference; } +IfcExternalReference::IfcExternalReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternalReference)) throw; entity = e; } +// IfcExternallyDefinedHatchStyle +bool IfcExternallyDefinedHatchStyle::is(Type::Enum v) { return v == Type::IfcExternallyDefinedHatchStyle || IfcExternalReference::is(v); } +Type::Enum IfcExternallyDefinedHatchStyle::type() { return Type::IfcExternallyDefinedHatchStyle; } +Type::Enum IfcExternallyDefinedHatchStyle::Class() { return Type::IfcExternallyDefinedHatchStyle; } +IfcExternallyDefinedHatchStyle::IfcExternallyDefinedHatchStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedHatchStyle)) throw; entity = e; } +// IfcExternallyDefinedSurfaceStyle +bool IfcExternallyDefinedSurfaceStyle::is(Type::Enum v) { return v == Type::IfcExternallyDefinedSurfaceStyle || IfcExternalReference::is(v); } +Type::Enum IfcExternallyDefinedSurfaceStyle::type() { return Type::IfcExternallyDefinedSurfaceStyle; } +Type::Enum IfcExternallyDefinedSurfaceStyle::Class() { return Type::IfcExternallyDefinedSurfaceStyle; } +IfcExternallyDefinedSurfaceStyle::IfcExternallyDefinedSurfaceStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedSurfaceStyle)) throw; entity = e; } +// IfcExternallyDefinedSymbol +bool IfcExternallyDefinedSymbol::is(Type::Enum v) { return v == Type::IfcExternallyDefinedSymbol || IfcExternalReference::is(v); } +Type::Enum IfcExternallyDefinedSymbol::type() { return Type::IfcExternallyDefinedSymbol; } +Type::Enum IfcExternallyDefinedSymbol::Class() { return Type::IfcExternallyDefinedSymbol; } +IfcExternallyDefinedSymbol::IfcExternallyDefinedSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedSymbol)) throw; entity = e; } +// IfcExternallyDefinedTextFont +bool IfcExternallyDefinedTextFont::is(Type::Enum v) { return v == Type::IfcExternallyDefinedTextFont || IfcExternalReference::is(v); } +Type::Enum IfcExternallyDefinedTextFont::type() { return Type::IfcExternallyDefinedTextFont; } +Type::Enum IfcExternallyDefinedTextFont::Class() { return Type::IfcExternallyDefinedTextFont; } +IfcExternallyDefinedTextFont::IfcExternallyDefinedTextFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedTextFont)) throw; entity = e; } +// IfcExtrudedAreaSolid +SHARED_PTR IfcExtrudedAreaSolid::ExtrudedDirection() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +IfcPositiveLengthMeasure IfcExtrudedAreaSolid::Depth() { return *entity->getArgument(3); } +bool IfcExtrudedAreaSolid::is(Type::Enum v) { return v == Type::IfcExtrudedAreaSolid || IfcSweptAreaSolid::is(v); } +Type::Enum IfcExtrudedAreaSolid::type() { return Type::IfcExtrudedAreaSolid; } +Type::Enum IfcExtrudedAreaSolid::Class() { return Type::IfcExtrudedAreaSolid; } +IfcExtrudedAreaSolid::IfcExtrudedAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcExtrudedAreaSolid)) throw; entity = e; } +// IfcFace +SHARED_PTR< IfcTemplatedEntityList > IfcFace::Bounds() { RETURN_AS_LIST(IfcFaceBound,0) } +bool IfcFace::is(Type::Enum v) { return v == Type::IfcFace || IfcTopologicalRepresentationItem::is(v); } +Type::Enum IfcFace::type() { return Type::IfcFace; } +Type::Enum IfcFace::Class() { return Type::IfcFace; } +IfcFace::IfcFace(IfcAbstractEntityPtr e) { if (!is(Type::IfcFace)) throw; entity = e; } +// IfcFaceBasedSurfaceModel +SHARED_PTR< IfcTemplatedEntityList > IfcFaceBasedSurfaceModel::FbsmFaces() { RETURN_AS_LIST(IfcConnectedFaceSet,0) } +bool IfcFaceBasedSurfaceModel::is(Type::Enum v) { return v == Type::IfcFaceBasedSurfaceModel || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcFaceBasedSurfaceModel::type() { return Type::IfcFaceBasedSurfaceModel; } +Type::Enum IfcFaceBasedSurfaceModel::Class() { return Type::IfcFaceBasedSurfaceModel; } +IfcFaceBasedSurfaceModel::IfcFaceBasedSurfaceModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceBasedSurfaceModel)) throw; entity = e; } +// IfcFaceBound +SHARED_PTR IfcFaceBound::Bound() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcFaceBound::Orientation() { return *entity->getArgument(1); } +bool IfcFaceBound::is(Type::Enum v) { return v == Type::IfcFaceBound || IfcTopologicalRepresentationItem::is(v); } +Type::Enum IfcFaceBound::type() { return Type::IfcFaceBound; } +Type::Enum IfcFaceBound::Class() { return Type::IfcFaceBound; } +IfcFaceBound::IfcFaceBound(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceBound)) throw; entity = e; } +// IfcFaceOuterBound +bool IfcFaceOuterBound::is(Type::Enum v) { return v == Type::IfcFaceOuterBound || IfcFaceBound::is(v); } +Type::Enum IfcFaceOuterBound::type() { return Type::IfcFaceOuterBound; } +Type::Enum IfcFaceOuterBound::Class() { return Type::IfcFaceOuterBound; } +IfcFaceOuterBound::IfcFaceOuterBound(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceOuterBound)) throw; entity = e; } +// IfcFaceSurface +SHARED_PTR IfcFaceSurface::FaceSurface() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcFaceSurface::SameSense() { return *entity->getArgument(2); } +bool IfcFaceSurface::is(Type::Enum v) { return v == Type::IfcFaceSurface || IfcFace::is(v); } +Type::Enum IfcFaceSurface::type() { return Type::IfcFaceSurface; } +Type::Enum IfcFaceSurface::Class() { return Type::IfcFaceSurface; } +IfcFaceSurface::IfcFaceSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceSurface)) throw; entity = e; } +// IfcFacetedBrep +bool IfcFacetedBrep::is(Type::Enum v) { return v == Type::IfcFacetedBrep || IfcManifoldSolidBrep::is(v); } +Type::Enum IfcFacetedBrep::type() { return Type::IfcFacetedBrep; } +Type::Enum IfcFacetedBrep::Class() { return Type::IfcFacetedBrep; } +IfcFacetedBrep::IfcFacetedBrep(IfcAbstractEntityPtr e) { if (!is(Type::IfcFacetedBrep)) throw; entity = e; } +// IfcFacetedBrepWithVoids +SHARED_PTR< IfcTemplatedEntityList > IfcFacetedBrepWithVoids::Voids() { RETURN_AS_LIST(IfcClosedShell,1) } +bool IfcFacetedBrepWithVoids::is(Type::Enum v) { return v == Type::IfcFacetedBrepWithVoids || IfcManifoldSolidBrep::is(v); } +Type::Enum IfcFacetedBrepWithVoids::type() { return Type::IfcFacetedBrepWithVoids; } +Type::Enum IfcFacetedBrepWithVoids::Class() { return Type::IfcFacetedBrepWithVoids; } +IfcFacetedBrepWithVoids::IfcFacetedBrepWithVoids(IfcAbstractEntityPtr e) { if (!is(Type::IfcFacetedBrepWithVoids)) throw; entity = e; } +// IfcFailureConnectionCondition +bool IfcFailureConnectionCondition::hasTensionFailureX() { return !entity->getArgument(1)->isNull(); } +IfcForceMeasure IfcFailureConnectionCondition::TensionFailureX() { return *entity->getArgument(1); } +bool IfcFailureConnectionCondition::hasTensionFailureY() { return !entity->getArgument(2)->isNull(); } +IfcForceMeasure IfcFailureConnectionCondition::TensionFailureY() { return *entity->getArgument(2); } +bool IfcFailureConnectionCondition::hasTensionFailureZ() { return !entity->getArgument(3)->isNull(); } +IfcForceMeasure IfcFailureConnectionCondition::TensionFailureZ() { return *entity->getArgument(3); } +bool IfcFailureConnectionCondition::hasCompressionFailureX() { return !entity->getArgument(4)->isNull(); } +IfcForceMeasure IfcFailureConnectionCondition::CompressionFailureX() { return *entity->getArgument(4); } +bool IfcFailureConnectionCondition::hasCompressionFailureY() { return !entity->getArgument(5)->isNull(); } +IfcForceMeasure IfcFailureConnectionCondition::CompressionFailureY() { return *entity->getArgument(5); } +bool IfcFailureConnectionCondition::hasCompressionFailureZ() { return !entity->getArgument(6)->isNull(); } +IfcForceMeasure IfcFailureConnectionCondition::CompressionFailureZ() { return *entity->getArgument(6); } +bool IfcFailureConnectionCondition::is(Type::Enum v) { return v == Type::IfcFailureConnectionCondition || IfcStructuralConnectionCondition::is(v); } +Type::Enum IfcFailureConnectionCondition::type() { return Type::IfcFailureConnectionCondition; } +Type::Enum IfcFailureConnectionCondition::Class() { return Type::IfcFailureConnectionCondition; } +IfcFailureConnectionCondition::IfcFailureConnectionCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcFailureConnectionCondition)) throw; entity = e; } +// IfcFanType +IfcFanTypeEnum::IfcFanTypeEnum IfcFanType::PredefinedType() { return IfcFanTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcFanType::is(Type::Enum v) { return v == Type::IfcFanType || IfcFlowMovingDeviceType::is(v); } +Type::Enum IfcFanType::type() { return Type::IfcFanType; } +Type::Enum IfcFanType::Class() { return Type::IfcFanType; } +IfcFanType::IfcFanType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFanType)) throw; entity = e; } +// IfcFastener +bool IfcFastener::is(Type::Enum v) { return v == Type::IfcFastener || IfcElementComponent::is(v); } +Type::Enum IfcFastener::type() { return Type::IfcFastener; } +Type::Enum IfcFastener::Class() { return Type::IfcFastener; } +IfcFastener::IfcFastener(IfcAbstractEntityPtr e) { if (!is(Type::IfcFastener)) throw; entity = e; } +// IfcFastenerType +bool IfcFastenerType::is(Type::Enum v) { return v == Type::IfcFastenerType || IfcElementComponentType::is(v); } +Type::Enum IfcFastenerType::type() { return Type::IfcFastenerType; } +Type::Enum IfcFastenerType::Class() { return Type::IfcFastenerType; } +IfcFastenerType::IfcFastenerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFastenerType)) throw; entity = e; } +// IfcFeatureElement +bool IfcFeatureElement::is(Type::Enum v) { return v == Type::IfcFeatureElement || IfcElement::is(v); } +Type::Enum IfcFeatureElement::type() { return Type::IfcFeatureElement; } +Type::Enum IfcFeatureElement::Class() { return Type::IfcFeatureElement; } +IfcFeatureElement::IfcFeatureElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcFeatureElement)) throw; entity = e; } +// IfcFeatureElementAddition +IfcRelProjectsElement::list IfcFeatureElementAddition::ProjectsElements() { RETURN_INVERSE(IfcRelProjectsElement) } +bool IfcFeatureElementAddition::is(Type::Enum v) { return v == Type::IfcFeatureElementAddition || IfcFeatureElement::is(v); } +Type::Enum IfcFeatureElementAddition::type() { return Type::IfcFeatureElementAddition; } +Type::Enum IfcFeatureElementAddition::Class() { return Type::IfcFeatureElementAddition; } +IfcFeatureElementAddition::IfcFeatureElementAddition(IfcAbstractEntityPtr e) { if (!is(Type::IfcFeatureElementAddition)) throw; entity = e; } +// IfcFeatureElementSubtraction +IfcRelVoidsElement::list IfcFeatureElementSubtraction::VoidsElements() { RETURN_INVERSE(IfcRelVoidsElement) } +bool IfcFeatureElementSubtraction::is(Type::Enum v) { return v == Type::IfcFeatureElementSubtraction || IfcFeatureElement::is(v); } +Type::Enum IfcFeatureElementSubtraction::type() { return Type::IfcFeatureElementSubtraction; } +Type::Enum IfcFeatureElementSubtraction::Class() { return Type::IfcFeatureElementSubtraction; } +IfcFeatureElementSubtraction::IfcFeatureElementSubtraction(IfcAbstractEntityPtr e) { if (!is(Type::IfcFeatureElementSubtraction)) throw; entity = e; } +// IfcFillAreaStyle +SHARED_PTR< IfcTemplatedEntityList > IfcFillAreaStyle::FillStyles() { RETURN_AS_LIST(IfcAbstractSelect,1) } +bool IfcFillAreaStyle::is(Type::Enum v) { return v == Type::IfcFillAreaStyle || IfcPresentationStyle::is(v); } +Type::Enum IfcFillAreaStyle::type() { return Type::IfcFillAreaStyle; } +Type::Enum IfcFillAreaStyle::Class() { return Type::IfcFillAreaStyle; } +IfcFillAreaStyle::IfcFillAreaStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyle)) throw; entity = e; } +// IfcFillAreaStyleHatching +SHARED_PTR IfcFillAreaStyleHatching::HatchLineAppearance() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcHatchLineDistanceSelect IfcFillAreaStyleHatching::StartOfNextHatchLine() { return *entity->getArgument(1); } +bool IfcFillAreaStyleHatching::hasPointOfReferenceHatchLine() { return !entity->getArgument(2)->isNull(); } +SHARED_PTR IfcFillAreaStyleHatching::PointOfReferenceHatchLine() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcFillAreaStyleHatching::hasPatternStart() { return !entity->getArgument(3)->isNull(); } +SHARED_PTR IfcFillAreaStyleHatching::PatternStart() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +IfcPlaneAngleMeasure IfcFillAreaStyleHatching::HatchLineAngle() { return *entity->getArgument(4); } +bool IfcFillAreaStyleHatching::is(Type::Enum v) { return v == Type::IfcFillAreaStyleHatching || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcFillAreaStyleHatching::type() { return Type::IfcFillAreaStyleHatching; } +Type::Enum IfcFillAreaStyleHatching::Class() { return Type::IfcFillAreaStyleHatching; } +IfcFillAreaStyleHatching::IfcFillAreaStyleHatching(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyleHatching)) throw; entity = e; } +// IfcFillAreaStyleTileSymbolWithStyle +SHARED_PTR IfcFillAreaStyleTileSymbolWithStyle::Symbol() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcFillAreaStyleTileSymbolWithStyle::is(Type::Enum v) { return v == Type::IfcFillAreaStyleTileSymbolWithStyle || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcFillAreaStyleTileSymbolWithStyle::type() { return Type::IfcFillAreaStyleTileSymbolWithStyle; } +Type::Enum IfcFillAreaStyleTileSymbolWithStyle::Class() { return Type::IfcFillAreaStyleTileSymbolWithStyle; } +IfcFillAreaStyleTileSymbolWithStyle::IfcFillAreaStyleTileSymbolWithStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyleTileSymbolWithStyle)) throw; entity = e; } +// IfcFillAreaStyleTiles +SHARED_PTR IfcFillAreaStyleTiles::TilingPattern() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR< IfcTemplatedEntityList > IfcFillAreaStyleTiles::Tiles() { RETURN_AS_LIST(IfcAbstractSelect,1) } +IfcPositiveRatioMeasure IfcFillAreaStyleTiles::TilingScale() { return *entity->getArgument(2); } +bool IfcFillAreaStyleTiles::is(Type::Enum v) { return v == Type::IfcFillAreaStyleTiles || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcFillAreaStyleTiles::type() { return Type::IfcFillAreaStyleTiles; } +Type::Enum IfcFillAreaStyleTiles::Class() { return Type::IfcFillAreaStyleTiles; } +IfcFillAreaStyleTiles::IfcFillAreaStyleTiles(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyleTiles)) throw; entity = e; } +// IfcFilterType +IfcFilterTypeEnum::IfcFilterTypeEnum IfcFilterType::PredefinedType() { return IfcFilterTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcFilterType::is(Type::Enum v) { return v == Type::IfcFilterType || IfcFlowTreatmentDeviceType::is(v); } +Type::Enum IfcFilterType::type() { return Type::IfcFilterType; } +Type::Enum IfcFilterType::Class() { return Type::IfcFilterType; } +IfcFilterType::IfcFilterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFilterType)) throw; entity = e; } +// IfcFireSuppressionTerminalType +IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum IfcFireSuppressionTerminalType::PredefinedType() { return IfcFireSuppressionTerminalTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcFireSuppressionTerminalType::is(Type::Enum v) { return v == Type::IfcFireSuppressionTerminalType || IfcFlowTerminalType::is(v); } +Type::Enum IfcFireSuppressionTerminalType::type() { return Type::IfcFireSuppressionTerminalType; } +Type::Enum IfcFireSuppressionTerminalType::Class() { return Type::IfcFireSuppressionTerminalType; } +IfcFireSuppressionTerminalType::IfcFireSuppressionTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFireSuppressionTerminalType)) throw; entity = e; } +// IfcFlowController +bool IfcFlowController::is(Type::Enum v) { return v == Type::IfcFlowController || IfcDistributionFlowElement::is(v); } +Type::Enum IfcFlowController::type() { return Type::IfcFlowController; } +Type::Enum IfcFlowController::Class() { return Type::IfcFlowController; } +IfcFlowController::IfcFlowController(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowController)) throw; entity = e; } +// IfcFlowControllerType +bool IfcFlowControllerType::is(Type::Enum v) { return v == Type::IfcFlowControllerType || IfcDistributionFlowElementType::is(v); } +Type::Enum IfcFlowControllerType::type() { return Type::IfcFlowControllerType; } +Type::Enum IfcFlowControllerType::Class() { return Type::IfcFlowControllerType; } +IfcFlowControllerType::IfcFlowControllerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowControllerType)) throw; entity = e; } +// IfcFlowFitting +bool IfcFlowFitting::is(Type::Enum v) { return v == Type::IfcFlowFitting || IfcDistributionFlowElement::is(v); } +Type::Enum IfcFlowFitting::type() { return Type::IfcFlowFitting; } +Type::Enum IfcFlowFitting::Class() { return Type::IfcFlowFitting; } +IfcFlowFitting::IfcFlowFitting(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowFitting)) throw; entity = e; } +// IfcFlowFittingType +bool IfcFlowFittingType::is(Type::Enum v) { return v == Type::IfcFlowFittingType || IfcDistributionFlowElementType::is(v); } +Type::Enum IfcFlowFittingType::type() { return Type::IfcFlowFittingType; } +Type::Enum IfcFlowFittingType::Class() { return Type::IfcFlowFittingType; } +IfcFlowFittingType::IfcFlowFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowFittingType)) throw; entity = e; } +// IfcFlowInstrumentType +IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum IfcFlowInstrumentType::PredefinedType() { return IfcFlowInstrumentTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcFlowInstrumentType::is(Type::Enum v) { return v == Type::IfcFlowInstrumentType || IfcDistributionControlElementType::is(v); } +Type::Enum IfcFlowInstrumentType::type() { return Type::IfcFlowInstrumentType; } +Type::Enum IfcFlowInstrumentType::Class() { return Type::IfcFlowInstrumentType; } +IfcFlowInstrumentType::IfcFlowInstrumentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowInstrumentType)) throw; entity = e; } +// IfcFlowMeterType +IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum IfcFlowMeterType::PredefinedType() { return IfcFlowMeterTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcFlowMeterType::is(Type::Enum v) { return v == Type::IfcFlowMeterType || IfcFlowControllerType::is(v); } +Type::Enum IfcFlowMeterType::type() { return Type::IfcFlowMeterType; } +Type::Enum IfcFlowMeterType::Class() { return Type::IfcFlowMeterType; } +IfcFlowMeterType::IfcFlowMeterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowMeterType)) throw; entity = e; } +// IfcFlowMovingDevice +bool IfcFlowMovingDevice::is(Type::Enum v) { return v == Type::IfcFlowMovingDevice || IfcDistributionFlowElement::is(v); } +Type::Enum IfcFlowMovingDevice::type() { return Type::IfcFlowMovingDevice; } +Type::Enum IfcFlowMovingDevice::Class() { return Type::IfcFlowMovingDevice; } +IfcFlowMovingDevice::IfcFlowMovingDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowMovingDevice)) throw; entity = e; } +// IfcFlowMovingDeviceType +bool IfcFlowMovingDeviceType::is(Type::Enum v) { return v == Type::IfcFlowMovingDeviceType || IfcDistributionFlowElementType::is(v); } +Type::Enum IfcFlowMovingDeviceType::type() { return Type::IfcFlowMovingDeviceType; } +Type::Enum IfcFlowMovingDeviceType::Class() { return Type::IfcFlowMovingDeviceType; } +IfcFlowMovingDeviceType::IfcFlowMovingDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowMovingDeviceType)) throw; entity = e; } +// IfcFlowSegment +bool IfcFlowSegment::is(Type::Enum v) { return v == Type::IfcFlowSegment || IfcDistributionFlowElement::is(v); } +Type::Enum IfcFlowSegment::type() { return Type::IfcFlowSegment; } +Type::Enum IfcFlowSegment::Class() { return Type::IfcFlowSegment; } +IfcFlowSegment::IfcFlowSegment(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowSegment)) throw; entity = e; } +// IfcFlowSegmentType +bool IfcFlowSegmentType::is(Type::Enum v) { return v == Type::IfcFlowSegmentType || IfcDistributionFlowElementType::is(v); } +Type::Enum IfcFlowSegmentType::type() { return Type::IfcFlowSegmentType; } +Type::Enum IfcFlowSegmentType::Class() { return Type::IfcFlowSegmentType; } +IfcFlowSegmentType::IfcFlowSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowSegmentType)) throw; entity = e; } +// IfcFlowStorageDevice +bool IfcFlowStorageDevice::is(Type::Enum v) { return v == Type::IfcFlowStorageDevice || IfcDistributionFlowElement::is(v); } +Type::Enum IfcFlowStorageDevice::type() { return Type::IfcFlowStorageDevice; } +Type::Enum IfcFlowStorageDevice::Class() { return Type::IfcFlowStorageDevice; } +IfcFlowStorageDevice::IfcFlowStorageDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowStorageDevice)) throw; entity = e; } +// IfcFlowStorageDeviceType +bool IfcFlowStorageDeviceType::is(Type::Enum v) { return v == Type::IfcFlowStorageDeviceType || IfcDistributionFlowElementType::is(v); } +Type::Enum IfcFlowStorageDeviceType::type() { return Type::IfcFlowStorageDeviceType; } +Type::Enum IfcFlowStorageDeviceType::Class() { return Type::IfcFlowStorageDeviceType; } +IfcFlowStorageDeviceType::IfcFlowStorageDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowStorageDeviceType)) throw; entity = e; } +// IfcFlowTerminal +bool IfcFlowTerminal::is(Type::Enum v) { return v == Type::IfcFlowTerminal || IfcDistributionFlowElement::is(v); } +Type::Enum IfcFlowTerminal::type() { return Type::IfcFlowTerminal; } +Type::Enum IfcFlowTerminal::Class() { return Type::IfcFlowTerminal; } +IfcFlowTerminal::IfcFlowTerminal(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTerminal)) throw; entity = e; } +// IfcFlowTerminalType +bool IfcFlowTerminalType::is(Type::Enum v) { return v == Type::IfcFlowTerminalType || IfcDistributionFlowElementType::is(v); } +Type::Enum IfcFlowTerminalType::type() { return Type::IfcFlowTerminalType; } +Type::Enum IfcFlowTerminalType::Class() { return Type::IfcFlowTerminalType; } +IfcFlowTerminalType::IfcFlowTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTerminalType)) throw; entity = e; } +// IfcFlowTreatmentDevice +bool IfcFlowTreatmentDevice::is(Type::Enum v) { return v == Type::IfcFlowTreatmentDevice || IfcDistributionFlowElement::is(v); } +Type::Enum IfcFlowTreatmentDevice::type() { return Type::IfcFlowTreatmentDevice; } +Type::Enum IfcFlowTreatmentDevice::Class() { return Type::IfcFlowTreatmentDevice; } +IfcFlowTreatmentDevice::IfcFlowTreatmentDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTreatmentDevice)) throw; entity = e; } +// IfcFlowTreatmentDeviceType +bool IfcFlowTreatmentDeviceType::is(Type::Enum v) { return v == Type::IfcFlowTreatmentDeviceType || IfcDistributionFlowElementType::is(v); } +Type::Enum IfcFlowTreatmentDeviceType::type() { return Type::IfcFlowTreatmentDeviceType; } +Type::Enum IfcFlowTreatmentDeviceType::Class() { return Type::IfcFlowTreatmentDeviceType; } +IfcFlowTreatmentDeviceType::IfcFlowTreatmentDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTreatmentDeviceType)) throw; entity = e; } +// IfcFluidFlowProperties +IfcPropertySourceEnum::IfcPropertySourceEnum IfcFluidFlowProperties::PropertySource() { return IfcPropertySourceEnum::FromString(*entity->getArgument(4)); } +bool IfcFluidFlowProperties::hasFlowConditionTimeSeries() { return !entity->getArgument(5)->isNull(); } +SHARED_PTR IfcFluidFlowProperties::FlowConditionTimeSeries() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcFluidFlowProperties::hasVelocityTimeSeries() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR IfcFluidFlowProperties::VelocityTimeSeries() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcFluidFlowProperties::hasFlowrateTimeSeries() { return !entity->getArgument(7)->isNull(); } +SHARED_PTR IfcFluidFlowProperties::FlowrateTimeSeries() { return reinterpret_pointer_cast(*entity->getArgument(7)); } +SHARED_PTR IfcFluidFlowProperties::Fluid() { return reinterpret_pointer_cast(*entity->getArgument(8)); } +bool IfcFluidFlowProperties::hasPressureTimeSeries() { return !entity->getArgument(9)->isNull(); } +SHARED_PTR IfcFluidFlowProperties::PressureTimeSeries() { return reinterpret_pointer_cast(*entity->getArgument(9)); } +bool IfcFluidFlowProperties::hasUserDefinedPropertySource() { return !entity->getArgument(10)->isNull(); } +IfcLabel IfcFluidFlowProperties::UserDefinedPropertySource() { return *entity->getArgument(10); } +bool IfcFluidFlowProperties::hasTemperatureSingleValue() { return !entity->getArgument(11)->isNull(); } +IfcThermodynamicTemperatureMeasure IfcFluidFlowProperties::TemperatureSingleValue() { return *entity->getArgument(11); } +bool IfcFluidFlowProperties::hasWetBulbTemperatureSingleValue() { return !entity->getArgument(12)->isNull(); } +IfcThermodynamicTemperatureMeasure IfcFluidFlowProperties::WetBulbTemperatureSingleValue() { return *entity->getArgument(12); } +bool IfcFluidFlowProperties::hasWetBulbTemperatureTimeSeries() { return !entity->getArgument(13)->isNull(); } +SHARED_PTR IfcFluidFlowProperties::WetBulbTemperatureTimeSeries() { return reinterpret_pointer_cast(*entity->getArgument(13)); } +bool IfcFluidFlowProperties::hasTemperatureTimeSeries() { return !entity->getArgument(14)->isNull(); } +SHARED_PTR IfcFluidFlowProperties::TemperatureTimeSeries() { return reinterpret_pointer_cast(*entity->getArgument(14)); } +bool IfcFluidFlowProperties::hasFlowrateSingleValue() { return !entity->getArgument(15)->isNull(); } +IfcDerivedMeasureValue IfcFluidFlowProperties::FlowrateSingleValue() { return *entity->getArgument(15); } +bool IfcFluidFlowProperties::hasFlowConditionSingleValue() { return !entity->getArgument(16)->isNull(); } +IfcPositiveRatioMeasure IfcFluidFlowProperties::FlowConditionSingleValue() { return *entity->getArgument(16); } +bool IfcFluidFlowProperties::hasVelocitySingleValue() { return !entity->getArgument(17)->isNull(); } +IfcLinearVelocityMeasure IfcFluidFlowProperties::VelocitySingleValue() { return *entity->getArgument(17); } +bool IfcFluidFlowProperties::hasPressureSingleValue() { return !entity->getArgument(18)->isNull(); } +IfcPressureMeasure IfcFluidFlowProperties::PressureSingleValue() { return *entity->getArgument(18); } +bool IfcFluidFlowProperties::is(Type::Enum v) { return v == Type::IfcFluidFlowProperties || IfcPropertySetDefinition::is(v); } +Type::Enum IfcFluidFlowProperties::type() { return Type::IfcFluidFlowProperties; } +Type::Enum IfcFluidFlowProperties::Class() { return Type::IfcFluidFlowProperties; } +IfcFluidFlowProperties::IfcFluidFlowProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcFluidFlowProperties)) throw; entity = e; } +// IfcFooting +IfcFootingTypeEnum::IfcFootingTypeEnum IfcFooting::PredefinedType() { return IfcFootingTypeEnum::FromString(*entity->getArgument(8)); } +bool IfcFooting::is(Type::Enum v) { return v == Type::IfcFooting || IfcBuildingElement::is(v); } +Type::Enum IfcFooting::type() { return Type::IfcFooting; } +Type::Enum IfcFooting::Class() { return Type::IfcFooting; } +IfcFooting::IfcFooting(IfcAbstractEntityPtr e) { if (!is(Type::IfcFooting)) throw; entity = e; } +// IfcFuelProperties +bool IfcFuelProperties::hasCombustionTemperature() { return !entity->getArgument(1)->isNull(); } +IfcThermodynamicTemperatureMeasure IfcFuelProperties::CombustionTemperature() { return *entity->getArgument(1); } +bool IfcFuelProperties::hasCarbonContent() { return !entity->getArgument(2)->isNull(); } +IfcPositiveRatioMeasure IfcFuelProperties::CarbonContent() { return *entity->getArgument(2); } +bool IfcFuelProperties::hasLowerHeatingValue() { return !entity->getArgument(3)->isNull(); } +IfcHeatingValueMeasure IfcFuelProperties::LowerHeatingValue() { return *entity->getArgument(3); } +bool IfcFuelProperties::hasHigherHeatingValue() { return !entity->getArgument(4)->isNull(); } +IfcHeatingValueMeasure IfcFuelProperties::HigherHeatingValue() { return *entity->getArgument(4); } +bool IfcFuelProperties::is(Type::Enum v) { return v == Type::IfcFuelProperties || IfcMaterialProperties::is(v); } +Type::Enum IfcFuelProperties::type() { return Type::IfcFuelProperties; } +Type::Enum IfcFuelProperties::Class() { return Type::IfcFuelProperties; } +IfcFuelProperties::IfcFuelProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcFuelProperties)) throw; entity = e; } +// IfcFurnishingElement +bool IfcFurnishingElement::is(Type::Enum v) { return v == Type::IfcFurnishingElement || IfcElement::is(v); } +Type::Enum IfcFurnishingElement::type() { return Type::IfcFurnishingElement; } +Type::Enum IfcFurnishingElement::Class() { return Type::IfcFurnishingElement; } +IfcFurnishingElement::IfcFurnishingElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnishingElement)) throw; entity = e; } +// IfcFurnishingElementType +bool IfcFurnishingElementType::is(Type::Enum v) { return v == Type::IfcFurnishingElementType || IfcElementType::is(v); } +Type::Enum IfcFurnishingElementType::type() { return Type::IfcFurnishingElementType; } +Type::Enum IfcFurnishingElementType::Class() { return Type::IfcFurnishingElementType; } +IfcFurnishingElementType::IfcFurnishingElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnishingElementType)) throw; entity = e; } +// IfcFurnitureStandard +bool IfcFurnitureStandard::is(Type::Enum v) { return v == Type::IfcFurnitureStandard || IfcControl::is(v); } +Type::Enum IfcFurnitureStandard::type() { return Type::IfcFurnitureStandard; } +Type::Enum IfcFurnitureStandard::Class() { return Type::IfcFurnitureStandard; } +IfcFurnitureStandard::IfcFurnitureStandard(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnitureStandard)) throw; entity = e; } +// IfcFurnitureType +IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum IfcFurnitureType::AssemblyPlace() { return IfcAssemblyPlaceEnum::FromString(*entity->getArgument(9)); } +bool IfcFurnitureType::is(Type::Enum v) { return v == Type::IfcFurnitureType || IfcFurnishingElementType::is(v); } +Type::Enum IfcFurnitureType::type() { return Type::IfcFurnitureType; } +Type::Enum IfcFurnitureType::Class() { return Type::IfcFurnitureType; } +IfcFurnitureType::IfcFurnitureType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnitureType)) throw; entity = e; } +// IfcGasTerminalType +IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum IfcGasTerminalType::PredefinedType() { return IfcGasTerminalTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcGasTerminalType::is(Type::Enum v) { return v == Type::IfcGasTerminalType || IfcFlowTerminalType::is(v); } +Type::Enum IfcGasTerminalType::type() { return Type::IfcGasTerminalType; } +Type::Enum IfcGasTerminalType::Class() { return Type::IfcGasTerminalType; } +IfcGasTerminalType::IfcGasTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcGasTerminalType)) throw; entity = e; } +// IfcGeneralMaterialProperties +bool IfcGeneralMaterialProperties::hasMolecularWeight() { return !entity->getArgument(1)->isNull(); } +IfcMolecularWeightMeasure IfcGeneralMaterialProperties::MolecularWeight() { return *entity->getArgument(1); } +bool IfcGeneralMaterialProperties::hasPorosity() { return !entity->getArgument(2)->isNull(); } +IfcNormalisedRatioMeasure IfcGeneralMaterialProperties::Porosity() { return *entity->getArgument(2); } +bool IfcGeneralMaterialProperties::hasMassDensity() { return !entity->getArgument(3)->isNull(); } +IfcMassDensityMeasure IfcGeneralMaterialProperties::MassDensity() { return *entity->getArgument(3); } +bool IfcGeneralMaterialProperties::is(Type::Enum v) { return v == Type::IfcGeneralMaterialProperties || IfcMaterialProperties::is(v); } +Type::Enum IfcGeneralMaterialProperties::type() { return Type::IfcGeneralMaterialProperties; } +Type::Enum IfcGeneralMaterialProperties::Class() { return Type::IfcGeneralMaterialProperties; } +IfcGeneralMaterialProperties::IfcGeneralMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeneralMaterialProperties)) throw; entity = e; } +// IfcGeneralProfileProperties +bool IfcGeneralProfileProperties::hasPhysicalWeight() { return !entity->getArgument(2)->isNull(); } +IfcMassPerLengthMeasure IfcGeneralProfileProperties::PhysicalWeight() { return *entity->getArgument(2); } +bool IfcGeneralProfileProperties::hasPerimeter() { return !entity->getArgument(3)->isNull(); } +IfcPositiveLengthMeasure IfcGeneralProfileProperties::Perimeter() { return *entity->getArgument(3); } +bool IfcGeneralProfileProperties::hasMinimumPlateThickness() { return !entity->getArgument(4)->isNull(); } +IfcPositiveLengthMeasure IfcGeneralProfileProperties::MinimumPlateThickness() { return *entity->getArgument(4); } +bool IfcGeneralProfileProperties::hasMaximumPlateThickness() { return !entity->getArgument(5)->isNull(); } +IfcPositiveLengthMeasure IfcGeneralProfileProperties::MaximumPlateThickness() { return *entity->getArgument(5); } +bool IfcGeneralProfileProperties::hasCrossSectionArea() { return !entity->getArgument(6)->isNull(); } +IfcAreaMeasure IfcGeneralProfileProperties::CrossSectionArea() { return *entity->getArgument(6); } +bool IfcGeneralProfileProperties::is(Type::Enum v) { return v == Type::IfcGeneralProfileProperties || IfcProfileProperties::is(v); } +Type::Enum IfcGeneralProfileProperties::type() { return Type::IfcGeneralProfileProperties; } +Type::Enum IfcGeneralProfileProperties::Class() { return Type::IfcGeneralProfileProperties; } +IfcGeneralProfileProperties::IfcGeneralProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeneralProfileProperties)) throw; entity = e; } +// IfcGeometricCurveSet +bool IfcGeometricCurveSet::is(Type::Enum v) { return v == Type::IfcGeometricCurveSet || IfcGeometricSet::is(v); } +Type::Enum IfcGeometricCurveSet::type() { return Type::IfcGeometricCurveSet; } +Type::Enum IfcGeometricCurveSet::Class() { return Type::IfcGeometricCurveSet; } +IfcGeometricCurveSet::IfcGeometricCurveSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricCurveSet)) throw; entity = e; } +// IfcGeometricRepresentationContext +IfcDimensionCount IfcGeometricRepresentationContext::CoordinateSpaceDimension() { return *entity->getArgument(2); } +bool IfcGeometricRepresentationContext::hasPrecision() { return !entity->getArgument(3)->isNull(); } +float IfcGeometricRepresentationContext::Precision() { return *entity->getArgument(3); } +IfcAxis2Placement IfcGeometricRepresentationContext::WorldCoordinateSystem() { return *entity->getArgument(4); } +bool IfcGeometricRepresentationContext::hasTrueNorth() { return !entity->getArgument(5)->isNull(); } +SHARED_PTR IfcGeometricRepresentationContext::TrueNorth() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +IfcGeometricRepresentationSubContext::list IfcGeometricRepresentationContext::HasSubContexts() { RETURN_INVERSE(IfcGeometricRepresentationSubContext) } +bool IfcGeometricRepresentationContext::is(Type::Enum v) { return v == Type::IfcGeometricRepresentationContext || IfcRepresentationContext::is(v); } +Type::Enum IfcGeometricRepresentationContext::type() { return Type::IfcGeometricRepresentationContext; } +Type::Enum IfcGeometricRepresentationContext::Class() { return Type::IfcGeometricRepresentationContext; } +IfcGeometricRepresentationContext::IfcGeometricRepresentationContext(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricRepresentationContext)) throw; entity = e; } +// IfcGeometricRepresentationItem +bool IfcGeometricRepresentationItem::is(Type::Enum v) { return v == Type::IfcGeometricRepresentationItem || IfcRepresentationItem::is(v); } +Type::Enum IfcGeometricRepresentationItem::type() { return Type::IfcGeometricRepresentationItem; } +Type::Enum IfcGeometricRepresentationItem::Class() { return Type::IfcGeometricRepresentationItem; } +IfcGeometricRepresentationItem::IfcGeometricRepresentationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricRepresentationItem)) throw; entity = e; } +// IfcGeometricRepresentationSubContext +SHARED_PTR IfcGeometricRepresentationSubContext::ParentContext() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcGeometricRepresentationSubContext::hasTargetScale() { return !entity->getArgument(7)->isNull(); } +IfcPositiveRatioMeasure IfcGeometricRepresentationSubContext::TargetScale() { return *entity->getArgument(7); } +IfcGeometricProjectionEnum::IfcGeometricProjectionEnum IfcGeometricRepresentationSubContext::TargetView() { return IfcGeometricProjectionEnum::FromString(*entity->getArgument(8)); } +bool IfcGeometricRepresentationSubContext::hasUserDefinedTargetView() { return !entity->getArgument(9)->isNull(); } +IfcLabel IfcGeometricRepresentationSubContext::UserDefinedTargetView() { return *entity->getArgument(9); } +bool IfcGeometricRepresentationSubContext::is(Type::Enum v) { return v == Type::IfcGeometricRepresentationSubContext || IfcGeometricRepresentationContext::is(v); } +Type::Enum IfcGeometricRepresentationSubContext::type() { return Type::IfcGeometricRepresentationSubContext; } +Type::Enum IfcGeometricRepresentationSubContext::Class() { return Type::IfcGeometricRepresentationSubContext; } +IfcGeometricRepresentationSubContext::IfcGeometricRepresentationSubContext(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricRepresentationSubContext)) throw; entity = e; } +// IfcGeometricSet +SHARED_PTR< IfcTemplatedEntityList > IfcGeometricSet::Elements() { RETURN_AS_LIST(IfcAbstractSelect,0) } +bool IfcGeometricSet::is(Type::Enum v) { return v == Type::IfcGeometricSet || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcGeometricSet::type() { return Type::IfcGeometricSet; } +Type::Enum IfcGeometricSet::Class() { return Type::IfcGeometricSet; } +IfcGeometricSet::IfcGeometricSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricSet)) throw; entity = e; } +// IfcGrid +SHARED_PTR< IfcTemplatedEntityList > IfcGrid::UAxes() { RETURN_AS_LIST(IfcGridAxis,7) } +SHARED_PTR< IfcTemplatedEntityList > IfcGrid::VAxes() { RETURN_AS_LIST(IfcGridAxis,8) } +bool IfcGrid::hasWAxes() { return !entity->getArgument(9)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcGrid::WAxes() { RETURN_AS_LIST(IfcGridAxis,9) } +IfcRelContainedInSpatialStructure::list IfcGrid::ContainedInStructure() { RETURN_INVERSE(IfcRelContainedInSpatialStructure) } +bool IfcGrid::is(Type::Enum v) { return v == Type::IfcGrid || IfcProduct::is(v); } +Type::Enum IfcGrid::type() { return Type::IfcGrid; } +Type::Enum IfcGrid::Class() { return Type::IfcGrid; } +IfcGrid::IfcGrid(IfcAbstractEntityPtr e) { if (!is(Type::IfcGrid)) throw; entity = e; } +// IfcGridAxis +bool IfcGridAxis::hasAxisTag() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcGridAxis::AxisTag() { return *entity->getArgument(0); } +SHARED_PTR IfcGridAxis::AxisCurve() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +IfcBoolean IfcGridAxis::SameSense() { return *entity->getArgument(2); } +IfcGrid::list IfcGridAxis::PartOfW() { RETURN_INVERSE(IfcGrid) } +IfcGrid::list IfcGridAxis::PartOfV() { RETURN_INVERSE(IfcGrid) } +IfcGrid::list IfcGridAxis::PartOfU() { RETURN_INVERSE(IfcGrid) } +IfcVirtualGridIntersection::list IfcGridAxis::HasIntersections() { RETURN_INVERSE(IfcVirtualGridIntersection) } +bool IfcGridAxis::is(Type::Enum v) { return v == Type::IfcGridAxis; } +Type::Enum IfcGridAxis::type() { return Type::IfcGridAxis; } +Type::Enum IfcGridAxis::Class() { return Type::IfcGridAxis; } +IfcGridAxis::IfcGridAxis(IfcAbstractEntityPtr e) { if (!is(Type::IfcGridAxis)) throw; entity = e; } +// IfcGridPlacement +SHARED_PTR IfcGridPlacement::PlacementLocation() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcGridPlacement::hasPlacementRefDirection() { return !entity->getArgument(1)->isNull(); } +SHARED_PTR IfcGridPlacement::PlacementRefDirection() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcGridPlacement::is(Type::Enum v) { return v == Type::IfcGridPlacement || IfcObjectPlacement::is(v); } +Type::Enum IfcGridPlacement::type() { return Type::IfcGridPlacement; } +Type::Enum IfcGridPlacement::Class() { return Type::IfcGridPlacement; } +IfcGridPlacement::IfcGridPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcGridPlacement)) throw; entity = e; } +// IfcGroup +IfcRelAssignsToGroup::list IfcGroup::IsGroupedBy() { RETURN_INVERSE(IfcRelAssignsToGroup) } +bool IfcGroup::is(Type::Enum v) { return v == Type::IfcGroup || IfcObject::is(v); } +Type::Enum IfcGroup::type() { return Type::IfcGroup; } +Type::Enum IfcGroup::Class() { return Type::IfcGroup; } +IfcGroup::IfcGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcGroup)) throw; entity = e; } +// IfcHalfSpaceSolid +SHARED_PTR IfcHalfSpaceSolid::BaseSurface() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcHalfSpaceSolid::AgreementFlag() { return *entity->getArgument(1); } +bool IfcHalfSpaceSolid::is(Type::Enum v) { return v == Type::IfcHalfSpaceSolid || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcHalfSpaceSolid::type() { return Type::IfcHalfSpaceSolid; } +Type::Enum IfcHalfSpaceSolid::Class() { return Type::IfcHalfSpaceSolid; } +IfcHalfSpaceSolid::IfcHalfSpaceSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcHalfSpaceSolid)) throw; entity = e; } +// IfcHeatExchangerType +IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum IfcHeatExchangerType::PredefinedType() { return IfcHeatExchangerTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcHeatExchangerType::is(Type::Enum v) { return v == Type::IfcHeatExchangerType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcHeatExchangerType::type() { return Type::IfcHeatExchangerType; } +Type::Enum IfcHeatExchangerType::Class() { return Type::IfcHeatExchangerType; } +IfcHeatExchangerType::IfcHeatExchangerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcHeatExchangerType)) throw; entity = e; } +// IfcHumidifierType +IfcHumidifierTypeEnum::IfcHumidifierTypeEnum IfcHumidifierType::PredefinedType() { return IfcHumidifierTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcHumidifierType::is(Type::Enum v) { return v == Type::IfcHumidifierType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcHumidifierType::type() { return Type::IfcHumidifierType; } +Type::Enum IfcHumidifierType::Class() { return Type::IfcHumidifierType; } +IfcHumidifierType::IfcHumidifierType(IfcAbstractEntityPtr e) { if (!is(Type::IfcHumidifierType)) throw; entity = e; } +// IfcHygroscopicMaterialProperties +bool IfcHygroscopicMaterialProperties::hasUpperVaporResistanceFactor() { return !entity->getArgument(1)->isNull(); } +IfcPositiveRatioMeasure IfcHygroscopicMaterialProperties::UpperVaporResistanceFactor() { return *entity->getArgument(1); } +bool IfcHygroscopicMaterialProperties::hasLowerVaporResistanceFactor() { return !entity->getArgument(2)->isNull(); } +IfcPositiveRatioMeasure IfcHygroscopicMaterialProperties::LowerVaporResistanceFactor() { return *entity->getArgument(2); } +bool IfcHygroscopicMaterialProperties::hasIsothermalMoistureCapacity() { return !entity->getArgument(3)->isNull(); } +IfcIsothermalMoistureCapacityMeasure IfcHygroscopicMaterialProperties::IsothermalMoistureCapacity() { return *entity->getArgument(3); } +bool IfcHygroscopicMaterialProperties::hasVaporPermeability() { return !entity->getArgument(4)->isNull(); } +IfcVaporPermeabilityMeasure IfcHygroscopicMaterialProperties::VaporPermeability() { return *entity->getArgument(4); } +bool IfcHygroscopicMaterialProperties::hasMoistureDiffusivity() { return !entity->getArgument(5)->isNull(); } +IfcMoistureDiffusivityMeasure IfcHygroscopicMaterialProperties::MoistureDiffusivity() { return *entity->getArgument(5); } +bool IfcHygroscopicMaterialProperties::is(Type::Enum v) { return v == Type::IfcHygroscopicMaterialProperties || IfcMaterialProperties::is(v); } +Type::Enum IfcHygroscopicMaterialProperties::type() { return Type::IfcHygroscopicMaterialProperties; } +Type::Enum IfcHygroscopicMaterialProperties::Class() { return Type::IfcHygroscopicMaterialProperties; } +IfcHygroscopicMaterialProperties::IfcHygroscopicMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcHygroscopicMaterialProperties)) throw; entity = e; } +// IfcIShapeProfileDef +IfcPositiveLengthMeasure IfcIShapeProfileDef::OverallWidth() { return *entity->getArgument(3); } +IfcPositiveLengthMeasure IfcIShapeProfileDef::OverallDepth() { return *entity->getArgument(4); } +IfcPositiveLengthMeasure IfcIShapeProfileDef::WebThickness() { return *entity->getArgument(5); } +IfcPositiveLengthMeasure IfcIShapeProfileDef::FlangeThickness() { return *entity->getArgument(6); } +bool IfcIShapeProfileDef::hasFilletRadius() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcIShapeProfileDef::FilletRadius() { return *entity->getArgument(7); } +bool IfcIShapeProfileDef::is(Type::Enum v) { return v == Type::IfcIShapeProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcIShapeProfileDef::type() { return Type::IfcIShapeProfileDef; } +Type::Enum IfcIShapeProfileDef::Class() { return Type::IfcIShapeProfileDef; } +IfcIShapeProfileDef::IfcIShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcIShapeProfileDef)) throw; entity = e; } +// IfcImageTexture +IfcIdentifier IfcImageTexture::UrlReference() { return *entity->getArgument(4); } +bool IfcImageTexture::is(Type::Enum v) { return v == Type::IfcImageTexture || IfcSurfaceTexture::is(v); } +Type::Enum IfcImageTexture::type() { return Type::IfcImageTexture; } +Type::Enum IfcImageTexture::Class() { return Type::IfcImageTexture; } +IfcImageTexture::IfcImageTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcImageTexture)) throw; entity = e; } +// IfcInventory +IfcInventoryTypeEnum::IfcInventoryTypeEnum IfcInventory::InventoryType() { return IfcInventoryTypeEnum::FromString(*entity->getArgument(5)); } +IfcActorSelect IfcInventory::Jurisdiction() { return *entity->getArgument(6); } +SHARED_PTR< IfcTemplatedEntityList > IfcInventory::ResponsiblePersons() { RETURN_AS_LIST(IfcPerson,7) } +SHARED_PTR IfcInventory::LastUpdateDate() { return reinterpret_pointer_cast(*entity->getArgument(8)); } +bool IfcInventory::hasCurrentValue() { return !entity->getArgument(9)->isNull(); } +SHARED_PTR IfcInventory::CurrentValue() { return reinterpret_pointer_cast(*entity->getArgument(9)); } +bool IfcInventory::hasOriginalValue() { return !entity->getArgument(10)->isNull(); } +SHARED_PTR IfcInventory::OriginalValue() { return reinterpret_pointer_cast(*entity->getArgument(10)); } +bool IfcInventory::is(Type::Enum v) { return v == Type::IfcInventory || IfcGroup::is(v); } +Type::Enum IfcInventory::type() { return Type::IfcInventory; } +Type::Enum IfcInventory::Class() { return Type::IfcInventory; } +IfcInventory::IfcInventory(IfcAbstractEntityPtr e) { if (!is(Type::IfcInventory)) throw; entity = e; } +// IfcIrregularTimeSeries +SHARED_PTR< IfcTemplatedEntityList > IfcIrregularTimeSeries::Values() { RETURN_AS_LIST(IfcIrregularTimeSeriesValue,8) } +bool IfcIrregularTimeSeries::is(Type::Enum v) { return v == Type::IfcIrregularTimeSeries || IfcTimeSeries::is(v); } +Type::Enum IfcIrregularTimeSeries::type() { return Type::IfcIrregularTimeSeries; } +Type::Enum IfcIrregularTimeSeries::Class() { return Type::IfcIrregularTimeSeries; } +IfcIrregularTimeSeries::IfcIrregularTimeSeries(IfcAbstractEntityPtr e) { if (!is(Type::IfcIrregularTimeSeries)) throw; entity = e; } +// IfcIrregularTimeSeriesValue +IfcDateTimeSelect IfcIrregularTimeSeriesValue::TimeStamp() { return *entity->getArgument(0); } +SHARED_PTR< IfcTemplatedEntityList > IfcIrregularTimeSeriesValue::ListValues() { RETURN_AS_LIST(IfcAbstractSelect,1) } +bool IfcIrregularTimeSeriesValue::is(Type::Enum v) { return v == Type::IfcIrregularTimeSeriesValue; } +Type::Enum IfcIrregularTimeSeriesValue::type() { return Type::IfcIrregularTimeSeriesValue; } +Type::Enum IfcIrregularTimeSeriesValue::Class() { return Type::IfcIrregularTimeSeriesValue; } +IfcIrregularTimeSeriesValue::IfcIrregularTimeSeriesValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcIrregularTimeSeriesValue)) throw; entity = e; } +// IfcJunctionBoxType +IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum IfcJunctionBoxType::PredefinedType() { return IfcJunctionBoxTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcJunctionBoxType::is(Type::Enum v) { return v == Type::IfcJunctionBoxType || IfcFlowFittingType::is(v); } +Type::Enum IfcJunctionBoxType::type() { return Type::IfcJunctionBoxType; } +Type::Enum IfcJunctionBoxType::Class() { return Type::IfcJunctionBoxType; } +IfcJunctionBoxType::IfcJunctionBoxType(IfcAbstractEntityPtr e) { if (!is(Type::IfcJunctionBoxType)) throw; entity = e; } +// IfcLShapeProfileDef +IfcPositiveLengthMeasure IfcLShapeProfileDef::Depth() { return *entity->getArgument(3); } +bool IfcLShapeProfileDef::hasWidth() { return !entity->getArgument(4)->isNull(); } +IfcPositiveLengthMeasure IfcLShapeProfileDef::Width() { return *entity->getArgument(4); } +IfcPositiveLengthMeasure IfcLShapeProfileDef::Thickness() { return *entity->getArgument(5); } +bool IfcLShapeProfileDef::hasFilletRadius() { return !entity->getArgument(6)->isNull(); } +IfcPositiveLengthMeasure IfcLShapeProfileDef::FilletRadius() { return *entity->getArgument(6); } +bool IfcLShapeProfileDef::hasEdgeRadius() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcLShapeProfileDef::EdgeRadius() { return *entity->getArgument(7); } +bool IfcLShapeProfileDef::hasLegSlope() { return !entity->getArgument(8)->isNull(); } +IfcPlaneAngleMeasure IfcLShapeProfileDef::LegSlope() { return *entity->getArgument(8); } +bool IfcLShapeProfileDef::hasCentreOfGravityInX() { return !entity->getArgument(9)->isNull(); } +IfcPositiveLengthMeasure IfcLShapeProfileDef::CentreOfGravityInX() { return *entity->getArgument(9); } +bool IfcLShapeProfileDef::hasCentreOfGravityInY() { return !entity->getArgument(10)->isNull(); } +IfcPositiveLengthMeasure IfcLShapeProfileDef::CentreOfGravityInY() { return *entity->getArgument(10); } +bool IfcLShapeProfileDef::is(Type::Enum v) { return v == Type::IfcLShapeProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcLShapeProfileDef::type() { return Type::IfcLShapeProfileDef; } +Type::Enum IfcLShapeProfileDef::Class() { return Type::IfcLShapeProfileDef; } +IfcLShapeProfileDef::IfcLShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcLShapeProfileDef)) throw; entity = e; } +// IfcLaborResource +bool IfcLaborResource::hasSkillSet() { return !entity->getArgument(9)->isNull(); } +IfcText IfcLaborResource::SkillSet() { return *entity->getArgument(9); } +bool IfcLaborResource::is(Type::Enum v) { return v == Type::IfcLaborResource || IfcConstructionResource::is(v); } +Type::Enum IfcLaborResource::type() { return Type::IfcLaborResource; } +Type::Enum IfcLaborResource::Class() { return Type::IfcLaborResource; } +IfcLaborResource::IfcLaborResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcLaborResource)) throw; entity = e; } +// IfcLampType +IfcLampTypeEnum::IfcLampTypeEnum IfcLampType::PredefinedType() { return IfcLampTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcLampType::is(Type::Enum v) { return v == Type::IfcLampType || IfcFlowTerminalType::is(v); } +Type::Enum IfcLampType::type() { return Type::IfcLampType; } +Type::Enum IfcLampType::Class() { return Type::IfcLampType; } +IfcLampType::IfcLampType(IfcAbstractEntityPtr e) { if (!is(Type::IfcLampType)) throw; entity = e; } +// IfcLibraryInformation +IfcLabel IfcLibraryInformation::Name() { return *entity->getArgument(0); } +bool IfcLibraryInformation::hasVersion() { return !entity->getArgument(1)->isNull(); } +IfcLabel IfcLibraryInformation::Version() { return *entity->getArgument(1); } +bool IfcLibraryInformation::hasPublisher() { return !entity->getArgument(2)->isNull(); } +SHARED_PTR IfcLibraryInformation::Publisher() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcLibraryInformation::hasVersionDate() { return !entity->getArgument(3)->isNull(); } +SHARED_PTR IfcLibraryInformation::VersionDate() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcLibraryInformation::hasLibraryReference() { return !entity->getArgument(4)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcLibraryInformation::LibraryReference() { RETURN_AS_LIST(IfcLibraryReference,4) } +bool IfcLibraryInformation::is(Type::Enum v) { return v == Type::IfcLibraryInformation; } +Type::Enum IfcLibraryInformation::type() { return Type::IfcLibraryInformation; } +Type::Enum IfcLibraryInformation::Class() { return Type::IfcLibraryInformation; } +IfcLibraryInformation::IfcLibraryInformation(IfcAbstractEntityPtr e) { if (!is(Type::IfcLibraryInformation)) throw; entity = e; } +// IfcLibraryReference +IfcLibraryInformation::list IfcLibraryReference::ReferenceIntoLibrary() { RETURN_INVERSE(IfcLibraryInformation) } +bool IfcLibraryReference::is(Type::Enum v) { return v == Type::IfcLibraryReference || IfcExternalReference::is(v); } +Type::Enum IfcLibraryReference::type() { return Type::IfcLibraryReference; } +Type::Enum IfcLibraryReference::Class() { return Type::IfcLibraryReference; } +IfcLibraryReference::IfcLibraryReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcLibraryReference)) throw; entity = e; } +// IfcLightDistributionData +IfcPlaneAngleMeasure IfcLightDistributionData::MainPlaneAngle() { return *entity->getArgument(0); } +std::vector IfcLightDistributionData::SecondaryPlaneAngle() { return *entity->getArgument(1); } +std::vector IfcLightDistributionData::LuminousIntensity() { return *entity->getArgument(2); } +bool IfcLightDistributionData::is(Type::Enum v) { return v == Type::IfcLightDistributionData; } +Type::Enum IfcLightDistributionData::type() { return Type::IfcLightDistributionData; } +Type::Enum IfcLightDistributionData::Class() { return Type::IfcLightDistributionData; } +IfcLightDistributionData::IfcLightDistributionData(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightDistributionData)) throw; entity = e; } +// IfcLightFixtureType +IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum IfcLightFixtureType::PredefinedType() { return IfcLightFixtureTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcLightFixtureType::is(Type::Enum v) { return v == Type::IfcLightFixtureType || IfcFlowTerminalType::is(v); } +Type::Enum IfcLightFixtureType::type() { return Type::IfcLightFixtureType; } +Type::Enum IfcLightFixtureType::Class() { return Type::IfcLightFixtureType; } +IfcLightFixtureType::IfcLightFixtureType(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightFixtureType)) throw; entity = e; } +// IfcLightIntensityDistribution +IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum IfcLightIntensityDistribution::LightDistributionCurve() { return IfcLightDistributionCurveEnum::FromString(*entity->getArgument(0)); } +SHARED_PTR< IfcTemplatedEntityList > IfcLightIntensityDistribution::DistributionData() { RETURN_AS_LIST(IfcLightDistributionData,1) } +bool IfcLightIntensityDistribution::is(Type::Enum v) { return v == Type::IfcLightIntensityDistribution; } +Type::Enum IfcLightIntensityDistribution::type() { return Type::IfcLightIntensityDistribution; } +Type::Enum IfcLightIntensityDistribution::Class() { return Type::IfcLightIntensityDistribution; } +IfcLightIntensityDistribution::IfcLightIntensityDistribution(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightIntensityDistribution)) throw; entity = e; } +// IfcLightSource +bool IfcLightSource::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcLightSource::Name() { return *entity->getArgument(0); } +SHARED_PTR IfcLightSource::LightColour() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcLightSource::hasAmbientIntensity() { return !entity->getArgument(2)->isNull(); } +IfcNormalisedRatioMeasure IfcLightSource::AmbientIntensity() { return *entity->getArgument(2); } +bool IfcLightSource::hasIntensity() { return !entity->getArgument(3)->isNull(); } +IfcNormalisedRatioMeasure IfcLightSource::Intensity() { return *entity->getArgument(3); } +bool IfcLightSource::is(Type::Enum v) { return v == Type::IfcLightSource || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcLightSource::type() { return Type::IfcLightSource; } +Type::Enum IfcLightSource::Class() { return Type::IfcLightSource; } +IfcLightSource::IfcLightSource(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSource)) throw; entity = e; } +// IfcLightSourceAmbient +bool IfcLightSourceAmbient::is(Type::Enum v) { return v == Type::IfcLightSourceAmbient || IfcLightSource::is(v); } +Type::Enum IfcLightSourceAmbient::type() { return Type::IfcLightSourceAmbient; } +Type::Enum IfcLightSourceAmbient::Class() { return Type::IfcLightSourceAmbient; } +IfcLightSourceAmbient::IfcLightSourceAmbient(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceAmbient)) throw; entity = e; } +// IfcLightSourceDirectional +SHARED_PTR IfcLightSourceDirectional::Orientation() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +bool IfcLightSourceDirectional::is(Type::Enum v) { return v == Type::IfcLightSourceDirectional || IfcLightSource::is(v); } +Type::Enum IfcLightSourceDirectional::type() { return Type::IfcLightSourceDirectional; } +Type::Enum IfcLightSourceDirectional::Class() { return Type::IfcLightSourceDirectional; } +IfcLightSourceDirectional::IfcLightSourceDirectional(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceDirectional)) throw; entity = e; } +// IfcLightSourceGoniometric +SHARED_PTR IfcLightSourceGoniometric::Position() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +bool IfcLightSourceGoniometric::hasColourAppearance() { return !entity->getArgument(5)->isNull(); } +SHARED_PTR IfcLightSourceGoniometric::ColourAppearance() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +IfcThermodynamicTemperatureMeasure IfcLightSourceGoniometric::ColourTemperature() { return *entity->getArgument(6); } +IfcLuminousFluxMeasure IfcLightSourceGoniometric::LuminousFlux() { return *entity->getArgument(7); } +IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum IfcLightSourceGoniometric::LightEmissionSource() { return IfcLightEmissionSourceEnum::FromString(*entity->getArgument(8)); } +IfcLightDistributionDataSourceSelect IfcLightSourceGoniometric::LightDistributionDataSource() { return *entity->getArgument(9); } +bool IfcLightSourceGoniometric::is(Type::Enum v) { return v == Type::IfcLightSourceGoniometric || IfcLightSource::is(v); } +Type::Enum IfcLightSourceGoniometric::type() { return Type::IfcLightSourceGoniometric; } +Type::Enum IfcLightSourceGoniometric::Class() { return Type::IfcLightSourceGoniometric; } +IfcLightSourceGoniometric::IfcLightSourceGoniometric(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceGoniometric)) throw; entity = e; } +// IfcLightSourcePositional +SHARED_PTR IfcLightSourcePositional::Position() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +IfcPositiveLengthMeasure IfcLightSourcePositional::Radius() { return *entity->getArgument(5); } +IfcReal IfcLightSourcePositional::ConstantAttenuation() { return *entity->getArgument(6); } +IfcReal IfcLightSourcePositional::DistanceAttenuation() { return *entity->getArgument(7); } +IfcReal IfcLightSourcePositional::QuadricAttenuation() { return *entity->getArgument(8); } +bool IfcLightSourcePositional::is(Type::Enum v) { return v == Type::IfcLightSourcePositional || IfcLightSource::is(v); } +Type::Enum IfcLightSourcePositional::type() { return Type::IfcLightSourcePositional; } +Type::Enum IfcLightSourcePositional::Class() { return Type::IfcLightSourcePositional; } +IfcLightSourcePositional::IfcLightSourcePositional(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourcePositional)) throw; entity = e; } +// IfcLightSourceSpot +SHARED_PTR IfcLightSourceSpot::Orientation() { return reinterpret_pointer_cast(*entity->getArgument(9)); } +bool IfcLightSourceSpot::hasConcentrationExponent() { return !entity->getArgument(10)->isNull(); } +IfcReal IfcLightSourceSpot::ConcentrationExponent() { return *entity->getArgument(10); } +IfcPositivePlaneAngleMeasure IfcLightSourceSpot::SpreadAngle() { return *entity->getArgument(11); } +IfcPositivePlaneAngleMeasure IfcLightSourceSpot::BeamWidthAngle() { return *entity->getArgument(12); } +bool IfcLightSourceSpot::is(Type::Enum v) { return v == Type::IfcLightSourceSpot || IfcLightSourcePositional::is(v); } +Type::Enum IfcLightSourceSpot::type() { return Type::IfcLightSourceSpot; } +Type::Enum IfcLightSourceSpot::Class() { return Type::IfcLightSourceSpot; } +IfcLightSourceSpot::IfcLightSourceSpot(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceSpot)) throw; entity = e; } +// IfcLine +SHARED_PTR IfcLine::Pnt() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcLine::Dir() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcLine::is(Type::Enum v) { return v == Type::IfcLine || IfcCurve::is(v); } +Type::Enum IfcLine::type() { return Type::IfcLine; } +Type::Enum IfcLine::Class() { return Type::IfcLine; } +IfcLine::IfcLine(IfcAbstractEntityPtr e) { if (!is(Type::IfcLine)) throw; entity = e; } +// IfcLinearDimension +bool IfcLinearDimension::is(Type::Enum v) { return v == Type::IfcLinearDimension || IfcDimensionCurveDirectedCallout::is(v); } +Type::Enum IfcLinearDimension::type() { return Type::IfcLinearDimension; } +Type::Enum IfcLinearDimension::Class() { return Type::IfcLinearDimension; } +IfcLinearDimension::IfcLinearDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcLinearDimension)) throw; entity = e; } +// IfcLocalPlacement +bool IfcLocalPlacement::hasPlacementRelTo() { return !entity->getArgument(0)->isNull(); } +SHARED_PTR IfcLocalPlacement::PlacementRelTo() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcAxis2Placement IfcLocalPlacement::RelativePlacement() { return *entity->getArgument(1); } +bool IfcLocalPlacement::is(Type::Enum v) { return v == Type::IfcLocalPlacement || IfcObjectPlacement::is(v); } +Type::Enum IfcLocalPlacement::type() { return Type::IfcLocalPlacement; } +Type::Enum IfcLocalPlacement::Class() { return Type::IfcLocalPlacement; } +IfcLocalPlacement::IfcLocalPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcLocalPlacement)) throw; entity = e; } +// IfcLocalTime +IfcHourInDay IfcLocalTime::HourComponent() { return *entity->getArgument(0); } +bool IfcLocalTime::hasMinuteComponent() { return !entity->getArgument(1)->isNull(); } +IfcMinuteInHour IfcLocalTime::MinuteComponent() { return *entity->getArgument(1); } +bool IfcLocalTime::hasSecondComponent() { return !entity->getArgument(2)->isNull(); } +IfcSecondInMinute IfcLocalTime::SecondComponent() { return *entity->getArgument(2); } +bool IfcLocalTime::hasZone() { return !entity->getArgument(3)->isNull(); } +SHARED_PTR IfcLocalTime::Zone() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcLocalTime::hasDaylightSavingOffset() { return !entity->getArgument(4)->isNull(); } +IfcDaylightSavingHour IfcLocalTime::DaylightSavingOffset() { return *entity->getArgument(4); } +bool IfcLocalTime::is(Type::Enum v) { return v == Type::IfcLocalTime; } +Type::Enum IfcLocalTime::type() { return Type::IfcLocalTime; } +Type::Enum IfcLocalTime::Class() { return Type::IfcLocalTime; } +IfcLocalTime::IfcLocalTime(IfcAbstractEntityPtr e) { if (!is(Type::IfcLocalTime)) throw; entity = e; } +// IfcLoop +bool IfcLoop::is(Type::Enum v) { return v == Type::IfcLoop || IfcTopologicalRepresentationItem::is(v); } +Type::Enum IfcLoop::type() { return Type::IfcLoop; } +Type::Enum IfcLoop::Class() { return Type::IfcLoop; } +IfcLoop::IfcLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcLoop)) throw; entity = e; } +// IfcManifoldSolidBrep +SHARED_PTR IfcManifoldSolidBrep::Outer() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcManifoldSolidBrep::is(Type::Enum v) { return v == Type::IfcManifoldSolidBrep || IfcSolidModel::is(v); } +Type::Enum IfcManifoldSolidBrep::type() { return Type::IfcManifoldSolidBrep; } +Type::Enum IfcManifoldSolidBrep::Class() { return Type::IfcManifoldSolidBrep; } +IfcManifoldSolidBrep::IfcManifoldSolidBrep(IfcAbstractEntityPtr e) { if (!is(Type::IfcManifoldSolidBrep)) throw; entity = e; } +// IfcMappedItem +SHARED_PTR IfcMappedItem::MappingSource() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcMappedItem::MappingTarget() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcMappedItem::is(Type::Enum v) { return v == Type::IfcMappedItem || IfcRepresentationItem::is(v); } +Type::Enum IfcMappedItem::type() { return Type::IfcMappedItem; } +Type::Enum IfcMappedItem::Class() { return Type::IfcMappedItem; } +IfcMappedItem::IfcMappedItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcMappedItem)) throw; entity = e; } +// IfcMaterial +IfcLabel IfcMaterial::Name() { return *entity->getArgument(0); } +IfcMaterialDefinitionRepresentation::list IfcMaterial::HasRepresentation() { RETURN_INVERSE(IfcMaterialDefinitionRepresentation) } +IfcMaterialClassificationRelationship::list IfcMaterial::ClassifiedAs() { RETURN_INVERSE(IfcMaterialClassificationRelationship) } +bool IfcMaterial::is(Type::Enum v) { return v == Type::IfcMaterial; } +Type::Enum IfcMaterial::type() { return Type::IfcMaterial; } +Type::Enum IfcMaterial::Class() { return Type::IfcMaterial; } +IfcMaterial::IfcMaterial(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterial)) throw; entity = e; } +// IfcMaterialClassificationRelationship +SHARED_PTR< IfcTemplatedEntityList > IfcMaterialClassificationRelationship::MaterialClassifications() { RETURN_AS_LIST(IfcAbstractSelect,0) } +SHARED_PTR IfcMaterialClassificationRelationship::ClassifiedMaterial() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcMaterialClassificationRelationship::is(Type::Enum v) { return v == Type::IfcMaterialClassificationRelationship; } +Type::Enum IfcMaterialClassificationRelationship::type() { return Type::IfcMaterialClassificationRelationship; } +Type::Enum IfcMaterialClassificationRelationship::Class() { return Type::IfcMaterialClassificationRelationship; } +IfcMaterialClassificationRelationship::IfcMaterialClassificationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialClassificationRelationship)) throw; entity = e; } +// IfcMaterialDefinitionRepresentation +SHARED_PTR IfcMaterialDefinitionRepresentation::RepresentedMaterial() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcMaterialDefinitionRepresentation::is(Type::Enum v) { return v == Type::IfcMaterialDefinitionRepresentation || IfcProductRepresentation::is(v); } +Type::Enum IfcMaterialDefinitionRepresentation::type() { return Type::IfcMaterialDefinitionRepresentation; } +Type::Enum IfcMaterialDefinitionRepresentation::Class() { return Type::IfcMaterialDefinitionRepresentation; } +IfcMaterialDefinitionRepresentation::IfcMaterialDefinitionRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialDefinitionRepresentation)) throw; entity = e; } +// IfcMaterialLayer +bool IfcMaterialLayer::hasMaterial() { return !entity->getArgument(0)->isNull(); } +SHARED_PTR IfcMaterialLayer::Material() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcPositiveLengthMeasure IfcMaterialLayer::LayerThickness() { return *entity->getArgument(1); } +bool IfcMaterialLayer::hasIsVentilated() { return !entity->getArgument(2)->isNull(); } +IfcLogical IfcMaterialLayer::IsVentilated() { return *entity->getArgument(2); } +IfcMaterialLayerSet::list IfcMaterialLayer::ToMaterialLayerSet() { RETURN_INVERSE(IfcMaterialLayerSet) } +bool IfcMaterialLayer::is(Type::Enum v) { return v == Type::IfcMaterialLayer; } +Type::Enum IfcMaterialLayer::type() { return Type::IfcMaterialLayer; } +Type::Enum IfcMaterialLayer::Class() { return Type::IfcMaterialLayer; } +IfcMaterialLayer::IfcMaterialLayer(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialLayer)) throw; entity = e; } +// IfcMaterialLayerSet +SHARED_PTR< IfcTemplatedEntityList > IfcMaterialLayerSet::MaterialLayers() { RETURN_AS_LIST(IfcMaterialLayer,0) } +bool IfcMaterialLayerSet::hasLayerSetName() { return !entity->getArgument(1)->isNull(); } +IfcLabel IfcMaterialLayerSet::LayerSetName() { return *entity->getArgument(1); } +bool IfcMaterialLayerSet::is(Type::Enum v) { return v == Type::IfcMaterialLayerSet; } +Type::Enum IfcMaterialLayerSet::type() { return Type::IfcMaterialLayerSet; } +Type::Enum IfcMaterialLayerSet::Class() { return Type::IfcMaterialLayerSet; } +IfcMaterialLayerSet::IfcMaterialLayerSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialLayerSet)) throw; entity = e; } +// IfcMaterialLayerSetUsage +SHARED_PTR IfcMaterialLayerSetUsage::ForLayerSet() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum IfcMaterialLayerSetUsage::LayerSetDirection() { return IfcLayerSetDirectionEnum::FromString(*entity->getArgument(1)); } +IfcDirectionSenseEnum::IfcDirectionSenseEnum IfcMaterialLayerSetUsage::DirectionSense() { return IfcDirectionSenseEnum::FromString(*entity->getArgument(2)); } +IfcLengthMeasure IfcMaterialLayerSetUsage::OffsetFromReferenceLine() { return *entity->getArgument(3); } +bool IfcMaterialLayerSetUsage::is(Type::Enum v) { return v == Type::IfcMaterialLayerSetUsage; } +Type::Enum IfcMaterialLayerSetUsage::type() { return Type::IfcMaterialLayerSetUsage; } +Type::Enum IfcMaterialLayerSetUsage::Class() { return Type::IfcMaterialLayerSetUsage; } +IfcMaterialLayerSetUsage::IfcMaterialLayerSetUsage(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialLayerSetUsage)) throw; entity = e; } +// IfcMaterialList +SHARED_PTR< IfcTemplatedEntityList > IfcMaterialList::Materials() { RETURN_AS_LIST(IfcMaterial,0) } +bool IfcMaterialList::is(Type::Enum v) { return v == Type::IfcMaterialList; } +Type::Enum IfcMaterialList::type() { return Type::IfcMaterialList; } +Type::Enum IfcMaterialList::Class() { return Type::IfcMaterialList; } +IfcMaterialList::IfcMaterialList(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialList)) throw; entity = e; } +// IfcMaterialProperties +SHARED_PTR IfcMaterialProperties::Material() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcMaterialProperties::is(Type::Enum v) { return v == Type::IfcMaterialProperties; } +Type::Enum IfcMaterialProperties::type() { return Type::IfcMaterialProperties; } +Type::Enum IfcMaterialProperties::Class() { return Type::IfcMaterialProperties; } +IfcMaterialProperties::IfcMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialProperties)) throw; entity = e; } +// IfcMeasureWithUnit +IfcValue IfcMeasureWithUnit::ValueComponent() { return *entity->getArgument(0); } +IfcUnit IfcMeasureWithUnit::UnitComponent() { return *entity->getArgument(1); } +bool IfcMeasureWithUnit::is(Type::Enum v) { return v == Type::IfcMeasureWithUnit; } +Type::Enum IfcMeasureWithUnit::type() { return Type::IfcMeasureWithUnit; } +Type::Enum IfcMeasureWithUnit::Class() { return Type::IfcMeasureWithUnit; } +IfcMeasureWithUnit::IfcMeasureWithUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcMeasureWithUnit)) throw; entity = e; } +// IfcMechanicalConcreteMaterialProperties +bool IfcMechanicalConcreteMaterialProperties::hasCompressiveStrength() { return !entity->getArgument(6)->isNull(); } +IfcPressureMeasure IfcMechanicalConcreteMaterialProperties::CompressiveStrength() { return *entity->getArgument(6); } +bool IfcMechanicalConcreteMaterialProperties::hasMaxAggregateSize() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcMechanicalConcreteMaterialProperties::MaxAggregateSize() { return *entity->getArgument(7); } +bool IfcMechanicalConcreteMaterialProperties::hasAdmixturesDescription() { return !entity->getArgument(8)->isNull(); } +IfcText IfcMechanicalConcreteMaterialProperties::AdmixturesDescription() { return *entity->getArgument(8); } +bool IfcMechanicalConcreteMaterialProperties::hasWorkability() { return !entity->getArgument(9)->isNull(); } +IfcText IfcMechanicalConcreteMaterialProperties::Workability() { return *entity->getArgument(9); } +bool IfcMechanicalConcreteMaterialProperties::hasProtectivePoreRatio() { return !entity->getArgument(10)->isNull(); } +IfcNormalisedRatioMeasure IfcMechanicalConcreteMaterialProperties::ProtectivePoreRatio() { return *entity->getArgument(10); } +bool IfcMechanicalConcreteMaterialProperties::hasWaterImpermeability() { return !entity->getArgument(11)->isNull(); } +IfcText IfcMechanicalConcreteMaterialProperties::WaterImpermeability() { return *entity->getArgument(11); } +bool IfcMechanicalConcreteMaterialProperties::is(Type::Enum v) { return v == Type::IfcMechanicalConcreteMaterialProperties || IfcMechanicalMaterialProperties::is(v); } +Type::Enum IfcMechanicalConcreteMaterialProperties::type() { return Type::IfcMechanicalConcreteMaterialProperties; } +Type::Enum IfcMechanicalConcreteMaterialProperties::Class() { return Type::IfcMechanicalConcreteMaterialProperties; } +IfcMechanicalConcreteMaterialProperties::IfcMechanicalConcreteMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalConcreteMaterialProperties)) throw; entity = e; } +// IfcMechanicalFastener +bool IfcMechanicalFastener::hasNominalDiameter() { return !entity->getArgument(8)->isNull(); } +IfcPositiveLengthMeasure IfcMechanicalFastener::NominalDiameter() { return *entity->getArgument(8); } +bool IfcMechanicalFastener::hasNominalLength() { return !entity->getArgument(9)->isNull(); } +IfcPositiveLengthMeasure IfcMechanicalFastener::NominalLength() { return *entity->getArgument(9); } +bool IfcMechanicalFastener::is(Type::Enum v) { return v == Type::IfcMechanicalFastener || IfcFastener::is(v); } +Type::Enum IfcMechanicalFastener::type() { return Type::IfcMechanicalFastener; } +Type::Enum IfcMechanicalFastener::Class() { return Type::IfcMechanicalFastener; } +IfcMechanicalFastener::IfcMechanicalFastener(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalFastener)) throw; entity = e; } +// IfcMechanicalFastenerType +bool IfcMechanicalFastenerType::is(Type::Enum v) { return v == Type::IfcMechanicalFastenerType || IfcFastenerType::is(v); } +Type::Enum IfcMechanicalFastenerType::type() { return Type::IfcMechanicalFastenerType; } +Type::Enum IfcMechanicalFastenerType::Class() { return Type::IfcMechanicalFastenerType; } +IfcMechanicalFastenerType::IfcMechanicalFastenerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalFastenerType)) throw; entity = e; } +// IfcMechanicalMaterialProperties +bool IfcMechanicalMaterialProperties::hasDynamicViscosity() { return !entity->getArgument(1)->isNull(); } +IfcDynamicViscosityMeasure IfcMechanicalMaterialProperties::DynamicViscosity() { return *entity->getArgument(1); } +bool IfcMechanicalMaterialProperties::hasYoungModulus() { return !entity->getArgument(2)->isNull(); } +IfcModulusOfElasticityMeasure IfcMechanicalMaterialProperties::YoungModulus() { return *entity->getArgument(2); } +bool IfcMechanicalMaterialProperties::hasShearModulus() { return !entity->getArgument(3)->isNull(); } +IfcModulusOfElasticityMeasure IfcMechanicalMaterialProperties::ShearModulus() { return *entity->getArgument(3); } +bool IfcMechanicalMaterialProperties::hasPoissonRatio() { return !entity->getArgument(4)->isNull(); } +IfcPositiveRatioMeasure IfcMechanicalMaterialProperties::PoissonRatio() { return *entity->getArgument(4); } +bool IfcMechanicalMaterialProperties::hasThermalExpansionCoefficient() { return !entity->getArgument(5)->isNull(); } +IfcThermalExpansionCoefficientMeasure IfcMechanicalMaterialProperties::ThermalExpansionCoefficient() { return *entity->getArgument(5); } +bool IfcMechanicalMaterialProperties::is(Type::Enum v) { return v == Type::IfcMechanicalMaterialProperties || IfcMaterialProperties::is(v); } +Type::Enum IfcMechanicalMaterialProperties::type() { return Type::IfcMechanicalMaterialProperties; } +Type::Enum IfcMechanicalMaterialProperties::Class() { return Type::IfcMechanicalMaterialProperties; } +IfcMechanicalMaterialProperties::IfcMechanicalMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalMaterialProperties)) throw; entity = e; } +// IfcMechanicalSteelMaterialProperties +bool IfcMechanicalSteelMaterialProperties::hasYieldStress() { return !entity->getArgument(6)->isNull(); } +IfcPressureMeasure IfcMechanicalSteelMaterialProperties::YieldStress() { return *entity->getArgument(6); } +bool IfcMechanicalSteelMaterialProperties::hasUltimateStress() { return !entity->getArgument(7)->isNull(); } +IfcPressureMeasure IfcMechanicalSteelMaterialProperties::UltimateStress() { return *entity->getArgument(7); } +bool IfcMechanicalSteelMaterialProperties::hasUltimateStrain() { return !entity->getArgument(8)->isNull(); } +IfcPositiveRatioMeasure IfcMechanicalSteelMaterialProperties::UltimateStrain() { return *entity->getArgument(8); } +bool IfcMechanicalSteelMaterialProperties::hasHardeningModule() { return !entity->getArgument(9)->isNull(); } +IfcModulusOfElasticityMeasure IfcMechanicalSteelMaterialProperties::HardeningModule() { return *entity->getArgument(9); } +bool IfcMechanicalSteelMaterialProperties::hasProportionalStress() { return !entity->getArgument(10)->isNull(); } +IfcPressureMeasure IfcMechanicalSteelMaterialProperties::ProportionalStress() { return *entity->getArgument(10); } +bool IfcMechanicalSteelMaterialProperties::hasPlasticStrain() { return !entity->getArgument(11)->isNull(); } +IfcPositiveRatioMeasure IfcMechanicalSteelMaterialProperties::PlasticStrain() { return *entity->getArgument(11); } +bool IfcMechanicalSteelMaterialProperties::hasRelaxations() { return !entity->getArgument(12)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcMechanicalSteelMaterialProperties::Relaxations() { RETURN_AS_LIST(IfcRelaxation,12) } +bool IfcMechanicalSteelMaterialProperties::is(Type::Enum v) { return v == Type::IfcMechanicalSteelMaterialProperties || IfcMechanicalMaterialProperties::is(v); } +Type::Enum IfcMechanicalSteelMaterialProperties::type() { return Type::IfcMechanicalSteelMaterialProperties; } +Type::Enum IfcMechanicalSteelMaterialProperties::Class() { return Type::IfcMechanicalSteelMaterialProperties; } +IfcMechanicalSteelMaterialProperties::IfcMechanicalSteelMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalSteelMaterialProperties)) throw; entity = e; } +// IfcMember +bool IfcMember::is(Type::Enum v) { return v == Type::IfcMember || IfcBuildingElement::is(v); } +Type::Enum IfcMember::type() { return Type::IfcMember; } +Type::Enum IfcMember::Class() { return Type::IfcMember; } +IfcMember::IfcMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcMember)) throw; entity = e; } +// IfcMemberType +IfcMemberTypeEnum::IfcMemberTypeEnum IfcMemberType::PredefinedType() { return IfcMemberTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcMemberType::is(Type::Enum v) { return v == Type::IfcMemberType || IfcBuildingElementType::is(v); } +Type::Enum IfcMemberType::type() { return Type::IfcMemberType; } +Type::Enum IfcMemberType::Class() { return Type::IfcMemberType; } +IfcMemberType::IfcMemberType(IfcAbstractEntityPtr e) { if (!is(Type::IfcMemberType)) throw; entity = e; } +// IfcMetric +IfcBenchmarkEnum::IfcBenchmarkEnum IfcMetric::Benchmark() { return IfcBenchmarkEnum::FromString(*entity->getArgument(7)); } +bool IfcMetric::hasValueSource() { return !entity->getArgument(8)->isNull(); } +IfcLabel IfcMetric::ValueSource() { return *entity->getArgument(8); } +IfcMetricValueSelect IfcMetric::DataValue() { return *entity->getArgument(9); } +bool IfcMetric::is(Type::Enum v) { return v == Type::IfcMetric || IfcConstraint::is(v); } +Type::Enum IfcMetric::type() { return Type::IfcMetric; } +Type::Enum IfcMetric::Class() { return Type::IfcMetric; } +IfcMetric::IfcMetric(IfcAbstractEntityPtr e) { if (!is(Type::IfcMetric)) throw; entity = e; } +// IfcMonetaryUnit +IfcCurrencyEnum::IfcCurrencyEnum IfcMonetaryUnit::Currency() { return IfcCurrencyEnum::FromString(*entity->getArgument(0)); } +bool IfcMonetaryUnit::is(Type::Enum v) { return v == Type::IfcMonetaryUnit; } +Type::Enum IfcMonetaryUnit::type() { return Type::IfcMonetaryUnit; } +Type::Enum IfcMonetaryUnit::Class() { return Type::IfcMonetaryUnit; } +IfcMonetaryUnit::IfcMonetaryUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcMonetaryUnit)) throw; entity = e; } +// IfcMotorConnectionType +IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum IfcMotorConnectionType::PredefinedType() { return IfcMotorConnectionTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcMotorConnectionType::is(Type::Enum v) { return v == Type::IfcMotorConnectionType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcMotorConnectionType::type() { return Type::IfcMotorConnectionType; } +Type::Enum IfcMotorConnectionType::Class() { return Type::IfcMotorConnectionType; } +IfcMotorConnectionType::IfcMotorConnectionType(IfcAbstractEntityPtr e) { if (!is(Type::IfcMotorConnectionType)) throw; entity = e; } +// IfcMove +SHARED_PTR IfcMove::MoveFrom() { return reinterpret_pointer_cast(*entity->getArgument(10)); } +SHARED_PTR IfcMove::MoveTo() { return reinterpret_pointer_cast(*entity->getArgument(11)); } +bool IfcMove::hasPunchList() { return !entity->getArgument(12)->isNull(); } +std::vector IfcMove::PunchList() { return *entity->getArgument(12); } +bool IfcMove::is(Type::Enum v) { return v == Type::IfcMove || IfcTask::is(v); } +Type::Enum IfcMove::type() { return Type::IfcMove; } +Type::Enum IfcMove::Class() { return Type::IfcMove; } +IfcMove::IfcMove(IfcAbstractEntityPtr e) { if (!is(Type::IfcMove)) throw; entity = e; } +// IfcNamedUnit +SHARED_PTR IfcNamedUnit::Dimensions() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcUnitEnum::IfcUnitEnum IfcNamedUnit::UnitType() { return IfcUnitEnum::FromString(*entity->getArgument(1)); } +bool IfcNamedUnit::is(Type::Enum v) { return v == Type::IfcNamedUnit; } +Type::Enum IfcNamedUnit::type() { return Type::IfcNamedUnit; } +Type::Enum IfcNamedUnit::Class() { return Type::IfcNamedUnit; } +IfcNamedUnit::IfcNamedUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcNamedUnit)) throw; entity = e; } +// IfcObject +bool IfcObject::hasObjectType() { return !entity->getArgument(4)->isNull(); } +IfcLabel IfcObject::ObjectType() { return *entity->getArgument(4); } +IfcRelDefines::list IfcObject::IsDefinedBy() { RETURN_INVERSE(IfcRelDefines) } +bool IfcObject::is(Type::Enum v) { return v == Type::IfcObject || IfcObjectDefinition::is(v); } +Type::Enum IfcObject::type() { return Type::IfcObject; } +Type::Enum IfcObject::Class() { return Type::IfcObject; } +IfcObject::IfcObject(IfcAbstractEntityPtr e) { if (!is(Type::IfcObject)) throw; entity = e; } +// IfcObjectDefinition +IfcRelAssigns::list IfcObjectDefinition::HasAssignments() { RETURN_INVERSE(IfcRelAssigns) } +IfcRelDecomposes::list IfcObjectDefinition::IsDecomposedBy() { RETURN_INVERSE(IfcRelDecomposes) } +IfcRelDecomposes::list IfcObjectDefinition::Decomposes() { RETURN_INVERSE(IfcRelDecomposes) } +IfcRelAssociates::list IfcObjectDefinition::HasAssociations() { RETURN_INVERSE(IfcRelAssociates) } +bool IfcObjectDefinition::is(Type::Enum v) { return v == Type::IfcObjectDefinition || IfcRoot::is(v); } +Type::Enum IfcObjectDefinition::type() { return Type::IfcObjectDefinition; } +Type::Enum IfcObjectDefinition::Class() { return Type::IfcObjectDefinition; } +IfcObjectDefinition::IfcObjectDefinition(IfcAbstractEntityPtr e) { if (!is(Type::IfcObjectDefinition)) throw; entity = e; } +// IfcObjectPlacement +IfcProduct::list IfcObjectPlacement::PlacesObject() { RETURN_INVERSE(IfcProduct) } +IfcLocalPlacement::list IfcObjectPlacement::ReferencedByPlacements() { RETURN_INVERSE(IfcLocalPlacement) } +bool IfcObjectPlacement::is(Type::Enum v) { return v == Type::IfcObjectPlacement; } +Type::Enum IfcObjectPlacement::type() { return Type::IfcObjectPlacement; } +Type::Enum IfcObjectPlacement::Class() { return Type::IfcObjectPlacement; } +IfcObjectPlacement::IfcObjectPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcObjectPlacement)) throw; entity = e; } +// IfcObjective +bool IfcObjective::hasBenchmarkValues() { return !entity->getArgument(7)->isNull(); } +SHARED_PTR IfcObjective::BenchmarkValues() { return reinterpret_pointer_cast(*entity->getArgument(7)); } +bool IfcObjective::hasResultValues() { return !entity->getArgument(8)->isNull(); } +SHARED_PTR IfcObjective::ResultValues() { return reinterpret_pointer_cast(*entity->getArgument(8)); } +IfcObjectiveEnum::IfcObjectiveEnum IfcObjective::ObjectiveQualifier() { return IfcObjectiveEnum::FromString(*entity->getArgument(9)); } +bool IfcObjective::hasUserDefinedQualifier() { return !entity->getArgument(10)->isNull(); } +IfcLabel IfcObjective::UserDefinedQualifier() { return *entity->getArgument(10); } +bool IfcObjective::is(Type::Enum v) { return v == Type::IfcObjective || IfcConstraint::is(v); } +Type::Enum IfcObjective::type() { return Type::IfcObjective; } +Type::Enum IfcObjective::Class() { return Type::IfcObjective; } +IfcObjective::IfcObjective(IfcAbstractEntityPtr e) { if (!is(Type::IfcObjective)) throw; entity = e; } +// IfcOccupant +IfcOccupantTypeEnum::IfcOccupantTypeEnum IfcOccupant::PredefinedType() { return IfcOccupantTypeEnum::FromString(*entity->getArgument(6)); } +bool IfcOccupant::is(Type::Enum v) { return v == Type::IfcOccupant || IfcActor::is(v); } +Type::Enum IfcOccupant::type() { return Type::IfcOccupant; } +Type::Enum IfcOccupant::Class() { return Type::IfcOccupant; } +IfcOccupant::IfcOccupant(IfcAbstractEntityPtr e) { if (!is(Type::IfcOccupant)) throw; entity = e; } +// IfcOffsetCurve2D +SHARED_PTR IfcOffsetCurve2D::BasisCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcLengthMeasure IfcOffsetCurve2D::Distance() { return *entity->getArgument(1); } +bool IfcOffsetCurve2D::SelfIntersect() { return *entity->getArgument(2); } +bool IfcOffsetCurve2D::is(Type::Enum v) { return v == Type::IfcOffsetCurve2D || IfcCurve::is(v); } +Type::Enum IfcOffsetCurve2D::type() { return Type::IfcOffsetCurve2D; } +Type::Enum IfcOffsetCurve2D::Class() { return Type::IfcOffsetCurve2D; } +IfcOffsetCurve2D::IfcOffsetCurve2D(IfcAbstractEntityPtr e) { if (!is(Type::IfcOffsetCurve2D)) throw; entity = e; } +// IfcOffsetCurve3D +SHARED_PTR IfcOffsetCurve3D::BasisCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcLengthMeasure IfcOffsetCurve3D::Distance() { return *entity->getArgument(1); } +bool IfcOffsetCurve3D::SelfIntersect() { return *entity->getArgument(2); } +SHARED_PTR IfcOffsetCurve3D::RefDirection() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcOffsetCurve3D::is(Type::Enum v) { return v == Type::IfcOffsetCurve3D || IfcCurve::is(v); } +Type::Enum IfcOffsetCurve3D::type() { return Type::IfcOffsetCurve3D; } +Type::Enum IfcOffsetCurve3D::Class() { return Type::IfcOffsetCurve3D; } +IfcOffsetCurve3D::IfcOffsetCurve3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcOffsetCurve3D)) throw; entity = e; } +// IfcOneDirectionRepeatFactor +SHARED_PTR IfcOneDirectionRepeatFactor::RepeatFactor() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcOneDirectionRepeatFactor::is(Type::Enum v) { return v == Type::IfcOneDirectionRepeatFactor || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcOneDirectionRepeatFactor::type() { return Type::IfcOneDirectionRepeatFactor; } +Type::Enum IfcOneDirectionRepeatFactor::Class() { return Type::IfcOneDirectionRepeatFactor; } +IfcOneDirectionRepeatFactor::IfcOneDirectionRepeatFactor(IfcAbstractEntityPtr e) { if (!is(Type::IfcOneDirectionRepeatFactor)) throw; entity = e; } +// IfcOpenShell +bool IfcOpenShell::is(Type::Enum v) { return v == Type::IfcOpenShell || IfcConnectedFaceSet::is(v); } +Type::Enum IfcOpenShell::type() { return Type::IfcOpenShell; } +Type::Enum IfcOpenShell::Class() { return Type::IfcOpenShell; } +IfcOpenShell::IfcOpenShell(IfcAbstractEntityPtr e) { if (!is(Type::IfcOpenShell)) throw; entity = e; } +// IfcOpeningElement +IfcRelFillsElement::list IfcOpeningElement::HasFillings() { RETURN_INVERSE(IfcRelFillsElement) } +bool IfcOpeningElement::is(Type::Enum v) { return v == Type::IfcOpeningElement || IfcFeatureElementSubtraction::is(v); } +Type::Enum IfcOpeningElement::type() { return Type::IfcOpeningElement; } +Type::Enum IfcOpeningElement::Class() { return Type::IfcOpeningElement; } +IfcOpeningElement::IfcOpeningElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcOpeningElement)) throw; entity = e; } +// IfcOpticalMaterialProperties +bool IfcOpticalMaterialProperties::hasVisibleTransmittance() { return !entity->getArgument(1)->isNull(); } +IfcPositiveRatioMeasure IfcOpticalMaterialProperties::VisibleTransmittance() { return *entity->getArgument(1); } +bool IfcOpticalMaterialProperties::hasSolarTransmittance() { return !entity->getArgument(2)->isNull(); } +IfcPositiveRatioMeasure IfcOpticalMaterialProperties::SolarTransmittance() { return *entity->getArgument(2); } +bool IfcOpticalMaterialProperties::hasThermalIrTransmittance() { return !entity->getArgument(3)->isNull(); } +IfcPositiveRatioMeasure IfcOpticalMaterialProperties::ThermalIrTransmittance() { return *entity->getArgument(3); } +bool IfcOpticalMaterialProperties::hasThermalIrEmissivityBack() { return !entity->getArgument(4)->isNull(); } +IfcPositiveRatioMeasure IfcOpticalMaterialProperties::ThermalIrEmissivityBack() { return *entity->getArgument(4); } +bool IfcOpticalMaterialProperties::hasThermalIrEmissivityFront() { return !entity->getArgument(5)->isNull(); } +IfcPositiveRatioMeasure IfcOpticalMaterialProperties::ThermalIrEmissivityFront() { return *entity->getArgument(5); } +bool IfcOpticalMaterialProperties::hasVisibleReflectanceBack() { return !entity->getArgument(6)->isNull(); } +IfcPositiveRatioMeasure IfcOpticalMaterialProperties::VisibleReflectanceBack() { return *entity->getArgument(6); } +bool IfcOpticalMaterialProperties::hasVisibleReflectanceFront() { return !entity->getArgument(7)->isNull(); } +IfcPositiveRatioMeasure IfcOpticalMaterialProperties::VisibleReflectanceFront() { return *entity->getArgument(7); } +bool IfcOpticalMaterialProperties::hasSolarReflectanceFront() { return !entity->getArgument(8)->isNull(); } +IfcPositiveRatioMeasure IfcOpticalMaterialProperties::SolarReflectanceFront() { return *entity->getArgument(8); } +bool IfcOpticalMaterialProperties::hasSolarReflectanceBack() { return !entity->getArgument(9)->isNull(); } +IfcPositiveRatioMeasure IfcOpticalMaterialProperties::SolarReflectanceBack() { return *entity->getArgument(9); } +bool IfcOpticalMaterialProperties::is(Type::Enum v) { return v == Type::IfcOpticalMaterialProperties || IfcMaterialProperties::is(v); } +Type::Enum IfcOpticalMaterialProperties::type() { return Type::IfcOpticalMaterialProperties; } +Type::Enum IfcOpticalMaterialProperties::Class() { return Type::IfcOpticalMaterialProperties; } +IfcOpticalMaterialProperties::IfcOpticalMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcOpticalMaterialProperties)) throw; entity = e; } +// IfcOrderAction +IfcIdentifier IfcOrderAction::ActionID() { return *entity->getArgument(10); } +bool IfcOrderAction::is(Type::Enum v) { return v == Type::IfcOrderAction || IfcTask::is(v); } +Type::Enum IfcOrderAction::type() { return Type::IfcOrderAction; } +Type::Enum IfcOrderAction::Class() { return Type::IfcOrderAction; } +IfcOrderAction::IfcOrderAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrderAction)) throw; entity = e; } +// IfcOrganization +bool IfcOrganization::hasId() { return !entity->getArgument(0)->isNull(); } +IfcIdentifier IfcOrganization::Id() { return *entity->getArgument(0); } +IfcLabel IfcOrganization::Name() { return *entity->getArgument(1); } +bool IfcOrganization::hasDescription() { return !entity->getArgument(2)->isNull(); } +IfcText IfcOrganization::Description() { return *entity->getArgument(2); } +bool IfcOrganization::hasRoles() { return !entity->getArgument(3)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcOrganization::Roles() { RETURN_AS_LIST(IfcActorRole,3) } +bool IfcOrganization::hasAddresses() { return !entity->getArgument(4)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcOrganization::Addresses() { RETURN_AS_LIST(IfcAddress,4) } +IfcOrganizationRelationship::list IfcOrganization::IsRelatedBy() { RETURN_INVERSE(IfcOrganizationRelationship) } +IfcOrganizationRelationship::list IfcOrganization::Relates() { RETURN_INVERSE(IfcOrganizationRelationship) } +IfcPersonAndOrganization::list IfcOrganization::Engages() { RETURN_INVERSE(IfcPersonAndOrganization) } +bool IfcOrganization::is(Type::Enum v) { return v == Type::IfcOrganization; } +Type::Enum IfcOrganization::type() { return Type::IfcOrganization; } +Type::Enum IfcOrganization::Class() { return Type::IfcOrganization; } +IfcOrganization::IfcOrganization(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrganization)) throw; entity = e; } +// IfcOrganizationRelationship +IfcLabel IfcOrganizationRelationship::Name() { return *entity->getArgument(0); } +bool IfcOrganizationRelationship::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcOrganizationRelationship::Description() { return *entity->getArgument(1); } +SHARED_PTR IfcOrganizationRelationship::RelatingOrganization() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +SHARED_PTR< IfcTemplatedEntityList > IfcOrganizationRelationship::RelatedOrganizations() { RETURN_AS_LIST(IfcOrganization,3) } +bool IfcOrganizationRelationship::is(Type::Enum v) { return v == Type::IfcOrganizationRelationship; } +Type::Enum IfcOrganizationRelationship::type() { return Type::IfcOrganizationRelationship; } +Type::Enum IfcOrganizationRelationship::Class() { return Type::IfcOrganizationRelationship; } +IfcOrganizationRelationship::IfcOrganizationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrganizationRelationship)) throw; entity = e; } +// IfcOrientedEdge +SHARED_PTR IfcOrientedEdge::EdgeElement() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcOrientedEdge::Orientation() { return *entity->getArgument(3); } +bool IfcOrientedEdge::is(Type::Enum v) { return v == Type::IfcOrientedEdge || IfcEdge::is(v); } +Type::Enum IfcOrientedEdge::type() { return Type::IfcOrientedEdge; } +Type::Enum IfcOrientedEdge::Class() { return Type::IfcOrientedEdge; } +IfcOrientedEdge::IfcOrientedEdge(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrientedEdge)) throw; entity = e; } +// IfcOutletType +IfcOutletTypeEnum::IfcOutletTypeEnum IfcOutletType::PredefinedType() { return IfcOutletTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcOutletType::is(Type::Enum v) { return v == Type::IfcOutletType || IfcFlowTerminalType::is(v); } +Type::Enum IfcOutletType::type() { return Type::IfcOutletType; } +Type::Enum IfcOutletType::Class() { return Type::IfcOutletType; } +IfcOutletType::IfcOutletType(IfcAbstractEntityPtr e) { if (!is(Type::IfcOutletType)) throw; entity = e; } +// IfcOwnerHistory +SHARED_PTR IfcOwnerHistory::OwningUser() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcOwnerHistory::OwningApplication() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcOwnerHistory::hasState() { return !entity->getArgument(2)->isNull(); } +IfcStateEnum::IfcStateEnum IfcOwnerHistory::State() { return IfcStateEnum::FromString(*entity->getArgument(2)); } +IfcChangeActionEnum::IfcChangeActionEnum IfcOwnerHistory::ChangeAction() { return IfcChangeActionEnum::FromString(*entity->getArgument(3)); } +bool IfcOwnerHistory::hasLastModifiedDate() { return !entity->getArgument(4)->isNull(); } +IfcTimeStamp IfcOwnerHistory::LastModifiedDate() { return *entity->getArgument(4); } +bool IfcOwnerHistory::hasLastModifyingUser() { return !entity->getArgument(5)->isNull(); } +SHARED_PTR IfcOwnerHistory::LastModifyingUser() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcOwnerHistory::hasLastModifyingApplication() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR IfcOwnerHistory::LastModifyingApplication() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +IfcTimeStamp IfcOwnerHistory::CreationDate() { return *entity->getArgument(7); } +bool IfcOwnerHistory::is(Type::Enum v) { return v == Type::IfcOwnerHistory; } +Type::Enum IfcOwnerHistory::type() { return Type::IfcOwnerHistory; } +Type::Enum IfcOwnerHistory::Class() { return Type::IfcOwnerHistory; } +IfcOwnerHistory::IfcOwnerHistory(IfcAbstractEntityPtr e) { if (!is(Type::IfcOwnerHistory)) throw; entity = e; } +// IfcParameterizedProfileDef +SHARED_PTR IfcParameterizedProfileDef::Position() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcParameterizedProfileDef::is(Type::Enum v) { return v == Type::IfcParameterizedProfileDef || IfcProfileDef::is(v); } +Type::Enum IfcParameterizedProfileDef::type() { return Type::IfcParameterizedProfileDef; } +Type::Enum IfcParameterizedProfileDef::Class() { return Type::IfcParameterizedProfileDef; } +IfcParameterizedProfileDef::IfcParameterizedProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcParameterizedProfileDef)) throw; entity = e; } +// IfcPath +SHARED_PTR< IfcTemplatedEntityList > IfcPath::EdgeList() { RETURN_AS_LIST(IfcOrientedEdge,0) } +bool IfcPath::is(Type::Enum v) { return v == Type::IfcPath || IfcTopologicalRepresentationItem::is(v); } +Type::Enum IfcPath::type() { return Type::IfcPath; } +Type::Enum IfcPath::Class() { return Type::IfcPath; } +IfcPath::IfcPath(IfcAbstractEntityPtr e) { if (!is(Type::IfcPath)) throw; entity = e; } +// IfcPerformanceHistory +IfcLabel IfcPerformanceHistory::LifeCyclePhase() { return *entity->getArgument(5); } +bool IfcPerformanceHistory::is(Type::Enum v) { return v == Type::IfcPerformanceHistory || IfcControl::is(v); } +Type::Enum IfcPerformanceHistory::type() { return Type::IfcPerformanceHistory; } +Type::Enum IfcPerformanceHistory::Class() { return Type::IfcPerformanceHistory; } +IfcPerformanceHistory::IfcPerformanceHistory(IfcAbstractEntityPtr e) { if (!is(Type::IfcPerformanceHistory)) throw; entity = e; } +// IfcPermeableCoveringProperties +IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum IfcPermeableCoveringProperties::OperationType() { return IfcPermeableCoveringOperationEnum::FromString(*entity->getArgument(4)); } +IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum IfcPermeableCoveringProperties::PanelPosition() { return IfcWindowPanelPositionEnum::FromString(*entity->getArgument(5)); } +bool IfcPermeableCoveringProperties::hasFrameDepth() { return !entity->getArgument(6)->isNull(); } +IfcPositiveLengthMeasure IfcPermeableCoveringProperties::FrameDepth() { return *entity->getArgument(6); } +bool IfcPermeableCoveringProperties::hasFrameThickness() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcPermeableCoveringProperties::FrameThickness() { return *entity->getArgument(7); } +bool IfcPermeableCoveringProperties::hasShapeAspectStyle() { return !entity->getArgument(8)->isNull(); } +SHARED_PTR IfcPermeableCoveringProperties::ShapeAspectStyle() { return reinterpret_pointer_cast(*entity->getArgument(8)); } +bool IfcPermeableCoveringProperties::is(Type::Enum v) { return v == Type::IfcPermeableCoveringProperties || IfcPropertySetDefinition::is(v); } +Type::Enum IfcPermeableCoveringProperties::type() { return Type::IfcPermeableCoveringProperties; } +Type::Enum IfcPermeableCoveringProperties::Class() { return Type::IfcPermeableCoveringProperties; } +IfcPermeableCoveringProperties::IfcPermeableCoveringProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcPermeableCoveringProperties)) throw; entity = e; } +// IfcPermit +IfcIdentifier IfcPermit::PermitID() { return *entity->getArgument(5); } +bool IfcPermit::is(Type::Enum v) { return v == Type::IfcPermit || IfcControl::is(v); } +Type::Enum IfcPermit::type() { return Type::IfcPermit; } +Type::Enum IfcPermit::Class() { return Type::IfcPermit; } +IfcPermit::IfcPermit(IfcAbstractEntityPtr e) { if (!is(Type::IfcPermit)) throw; entity = e; } +// IfcPerson +bool IfcPerson::hasId() { return !entity->getArgument(0)->isNull(); } +IfcIdentifier IfcPerson::Id() { return *entity->getArgument(0); } +bool IfcPerson::hasFamilyName() { return !entity->getArgument(1)->isNull(); } +IfcLabel IfcPerson::FamilyName() { return *entity->getArgument(1); } +bool IfcPerson::hasGivenName() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcPerson::GivenName() { return *entity->getArgument(2); } +bool IfcPerson::hasMiddleNames() { return !entity->getArgument(3)->isNull(); } +std::vector IfcPerson::MiddleNames() { return *entity->getArgument(3); } +bool IfcPerson::hasPrefixTitles() { return !entity->getArgument(4)->isNull(); } +std::vector IfcPerson::PrefixTitles() { return *entity->getArgument(4); } +bool IfcPerson::hasSuffixTitles() { return !entity->getArgument(5)->isNull(); } +std::vector IfcPerson::SuffixTitles() { return *entity->getArgument(5); } +bool IfcPerson::hasRoles() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcPerson::Roles() { RETURN_AS_LIST(IfcActorRole,6) } +bool IfcPerson::hasAddresses() { return !entity->getArgument(7)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcPerson::Addresses() { RETURN_AS_LIST(IfcAddress,7) } +IfcPersonAndOrganization::list IfcPerson::EngagedIn() { RETURN_INVERSE(IfcPersonAndOrganization) } +bool IfcPerson::is(Type::Enum v) { return v == Type::IfcPerson; } +Type::Enum IfcPerson::type() { return Type::IfcPerson; } +Type::Enum IfcPerson::Class() { return Type::IfcPerson; } +IfcPerson::IfcPerson(IfcAbstractEntityPtr e) { if (!is(Type::IfcPerson)) throw; entity = e; } +// IfcPersonAndOrganization +SHARED_PTR IfcPersonAndOrganization::ThePerson() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcPersonAndOrganization::TheOrganization() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcPersonAndOrganization::hasRoles() { return !entity->getArgument(2)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcPersonAndOrganization::Roles() { RETURN_AS_LIST(IfcActorRole,2) } +bool IfcPersonAndOrganization::is(Type::Enum v) { return v == Type::IfcPersonAndOrganization; } +Type::Enum IfcPersonAndOrganization::type() { return Type::IfcPersonAndOrganization; } +Type::Enum IfcPersonAndOrganization::Class() { return Type::IfcPersonAndOrganization; } +IfcPersonAndOrganization::IfcPersonAndOrganization(IfcAbstractEntityPtr e) { if (!is(Type::IfcPersonAndOrganization)) throw; entity = e; } +// IfcPhysicalComplexQuantity +SHARED_PTR< IfcTemplatedEntityList > IfcPhysicalComplexQuantity::HasQuantities() { RETURN_AS_LIST(IfcPhysicalQuantity,2) } +IfcLabel IfcPhysicalComplexQuantity::Discrimination() { return *entity->getArgument(3); } +bool IfcPhysicalComplexQuantity::hasQuality() { return !entity->getArgument(4)->isNull(); } +IfcLabel IfcPhysicalComplexQuantity::Quality() { return *entity->getArgument(4); } +bool IfcPhysicalComplexQuantity::hasUsage() { return !entity->getArgument(5)->isNull(); } +IfcLabel IfcPhysicalComplexQuantity::Usage() { return *entity->getArgument(5); } +bool IfcPhysicalComplexQuantity::is(Type::Enum v) { return v == Type::IfcPhysicalComplexQuantity || IfcPhysicalQuantity::is(v); } +Type::Enum IfcPhysicalComplexQuantity::type() { return Type::IfcPhysicalComplexQuantity; } +Type::Enum IfcPhysicalComplexQuantity::Class() { return Type::IfcPhysicalComplexQuantity; } +IfcPhysicalComplexQuantity::IfcPhysicalComplexQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcPhysicalComplexQuantity)) throw; entity = e; } +// IfcPhysicalQuantity +IfcLabel IfcPhysicalQuantity::Name() { return *entity->getArgument(0); } +bool IfcPhysicalQuantity::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcPhysicalQuantity::Description() { return *entity->getArgument(1); } +IfcPhysicalComplexQuantity::list IfcPhysicalQuantity::PartOfComplex() { RETURN_INVERSE(IfcPhysicalComplexQuantity) } +bool IfcPhysicalQuantity::is(Type::Enum v) { return v == Type::IfcPhysicalQuantity; } +Type::Enum IfcPhysicalQuantity::type() { return Type::IfcPhysicalQuantity; } +Type::Enum IfcPhysicalQuantity::Class() { return Type::IfcPhysicalQuantity; } +IfcPhysicalQuantity::IfcPhysicalQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcPhysicalQuantity)) throw; entity = e; } +// IfcPhysicalSimpleQuantity +bool IfcPhysicalSimpleQuantity::hasUnit() { return !entity->getArgument(2)->isNull(); } +SHARED_PTR IfcPhysicalSimpleQuantity::Unit() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcPhysicalSimpleQuantity::is(Type::Enum v) { return v == Type::IfcPhysicalSimpleQuantity || IfcPhysicalQuantity::is(v); } +Type::Enum IfcPhysicalSimpleQuantity::type() { return Type::IfcPhysicalSimpleQuantity; } +Type::Enum IfcPhysicalSimpleQuantity::Class() { return Type::IfcPhysicalSimpleQuantity; } +IfcPhysicalSimpleQuantity::IfcPhysicalSimpleQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcPhysicalSimpleQuantity)) throw; entity = e; } +// IfcPile +IfcPileTypeEnum::IfcPileTypeEnum IfcPile::PredefinedType() { return IfcPileTypeEnum::FromString(*entity->getArgument(8)); } +bool IfcPile::hasConstructionType() { return !entity->getArgument(9)->isNull(); } +IfcPileConstructionEnum::IfcPileConstructionEnum IfcPile::ConstructionType() { return IfcPileConstructionEnum::FromString(*entity->getArgument(9)); } +bool IfcPile::is(Type::Enum v) { return v == Type::IfcPile || IfcBuildingElement::is(v); } +Type::Enum IfcPile::type() { return Type::IfcPile; } +Type::Enum IfcPile::Class() { return Type::IfcPile; } +IfcPile::IfcPile(IfcAbstractEntityPtr e) { if (!is(Type::IfcPile)) throw; entity = e; } +// IfcPipeFittingType +IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum IfcPipeFittingType::PredefinedType() { return IfcPipeFittingTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcPipeFittingType::is(Type::Enum v) { return v == Type::IfcPipeFittingType || IfcFlowFittingType::is(v); } +Type::Enum IfcPipeFittingType::type() { return Type::IfcPipeFittingType; } +Type::Enum IfcPipeFittingType::Class() { return Type::IfcPipeFittingType; } +IfcPipeFittingType::IfcPipeFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPipeFittingType)) throw; entity = e; } +// IfcPipeSegmentType +IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum IfcPipeSegmentType::PredefinedType() { return IfcPipeSegmentTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcPipeSegmentType::is(Type::Enum v) { return v == Type::IfcPipeSegmentType || IfcFlowSegmentType::is(v); } +Type::Enum IfcPipeSegmentType::type() { return Type::IfcPipeSegmentType; } +Type::Enum IfcPipeSegmentType::Class() { return Type::IfcPipeSegmentType; } +IfcPipeSegmentType::IfcPipeSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPipeSegmentType)) throw; entity = e; } +// IfcPixelTexture +IfcInteger IfcPixelTexture::Width() { return *entity->getArgument(4); } +IfcInteger IfcPixelTexture::Height() { return *entity->getArgument(5); } +IfcInteger IfcPixelTexture::ColourComponents() { return *entity->getArgument(6); } +std::vector IfcPixelTexture::Pixel() { throw; /* Not implemented argument 7 */ } +bool IfcPixelTexture::is(Type::Enum v) { return v == Type::IfcPixelTexture || IfcSurfaceTexture::is(v); } +Type::Enum IfcPixelTexture::type() { return Type::IfcPixelTexture; } +Type::Enum IfcPixelTexture::Class() { return Type::IfcPixelTexture; } +IfcPixelTexture::IfcPixelTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcPixelTexture)) throw; entity = e; } +// IfcPlacement +SHARED_PTR IfcPlacement::Location() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcPlacement::is(Type::Enum v) { return v == Type::IfcPlacement || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcPlacement::type() { return Type::IfcPlacement; } +Type::Enum IfcPlacement::Class() { return Type::IfcPlacement; } +IfcPlacement::IfcPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlacement)) throw; entity = e; } +// IfcPlanarBox +IfcAxis2Placement IfcPlanarBox::Placement() { return *entity->getArgument(2); } +bool IfcPlanarBox::is(Type::Enum v) { return v == Type::IfcPlanarBox || IfcPlanarExtent::is(v); } +Type::Enum IfcPlanarBox::type() { return Type::IfcPlanarBox; } +Type::Enum IfcPlanarBox::Class() { return Type::IfcPlanarBox; } +IfcPlanarBox::IfcPlanarBox(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlanarBox)) throw; entity = e; } +// IfcPlanarExtent +IfcLengthMeasure IfcPlanarExtent::SizeInX() { return *entity->getArgument(0); } +IfcLengthMeasure IfcPlanarExtent::SizeInY() { return *entity->getArgument(1); } +bool IfcPlanarExtent::is(Type::Enum v) { return v == Type::IfcPlanarExtent || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcPlanarExtent::type() { return Type::IfcPlanarExtent; } +Type::Enum IfcPlanarExtent::Class() { return Type::IfcPlanarExtent; } +IfcPlanarExtent::IfcPlanarExtent(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlanarExtent)) throw; entity = e; } +// IfcPlane +bool IfcPlane::is(Type::Enum v) { return v == Type::IfcPlane || IfcElementarySurface::is(v); } +Type::Enum IfcPlane::type() { return Type::IfcPlane; } +Type::Enum IfcPlane::Class() { return Type::IfcPlane; } +IfcPlane::IfcPlane(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlane)) throw; entity = e; } +// IfcPlate +bool IfcPlate::is(Type::Enum v) { return v == Type::IfcPlate || IfcBuildingElement::is(v); } +Type::Enum IfcPlate::type() { return Type::IfcPlate; } +Type::Enum IfcPlate::Class() { return Type::IfcPlate; } +IfcPlate::IfcPlate(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlate)) throw; entity = e; } +// IfcPlateType +IfcPlateTypeEnum::IfcPlateTypeEnum IfcPlateType::PredefinedType() { return IfcPlateTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcPlateType::is(Type::Enum v) { return v == Type::IfcPlateType || IfcBuildingElementType::is(v); } +Type::Enum IfcPlateType::type() { return Type::IfcPlateType; } +Type::Enum IfcPlateType::Class() { return Type::IfcPlateType; } +IfcPlateType::IfcPlateType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlateType)) throw; entity = e; } +// IfcPoint +bool IfcPoint::is(Type::Enum v) { return v == Type::IfcPoint || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcPoint::type() { return Type::IfcPoint; } +Type::Enum IfcPoint::Class() { return Type::IfcPoint; } +IfcPoint::IfcPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcPoint)) throw; entity = e; } +// IfcPointOnCurve +SHARED_PTR IfcPointOnCurve::BasisCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcParameterValue IfcPointOnCurve::PointParameter() { return *entity->getArgument(1); } +bool IfcPointOnCurve::is(Type::Enum v) { return v == Type::IfcPointOnCurve || IfcPoint::is(v); } +Type::Enum IfcPointOnCurve::type() { return Type::IfcPointOnCurve; } +Type::Enum IfcPointOnCurve::Class() { return Type::IfcPointOnCurve; } +IfcPointOnCurve::IfcPointOnCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcPointOnCurve)) throw; entity = e; } +// IfcPointOnSurface +SHARED_PTR IfcPointOnSurface::BasisSurface() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcParameterValue IfcPointOnSurface::PointParameterU() { return *entity->getArgument(1); } +IfcParameterValue IfcPointOnSurface::PointParameterV() { return *entity->getArgument(2); } +bool IfcPointOnSurface::is(Type::Enum v) { return v == Type::IfcPointOnSurface || IfcPoint::is(v); } +Type::Enum IfcPointOnSurface::type() { return Type::IfcPointOnSurface; } +Type::Enum IfcPointOnSurface::Class() { return Type::IfcPointOnSurface; } +IfcPointOnSurface::IfcPointOnSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcPointOnSurface)) throw; entity = e; } +// IfcPolyLoop +SHARED_PTR< IfcTemplatedEntityList > IfcPolyLoop::Polygon() { RETURN_AS_LIST(IfcCartesianPoint,0) } +bool IfcPolyLoop::is(Type::Enum v) { return v == Type::IfcPolyLoop || IfcLoop::is(v); } +Type::Enum IfcPolyLoop::type() { return Type::IfcPolyLoop; } +Type::Enum IfcPolyLoop::Class() { return Type::IfcPolyLoop; } +IfcPolyLoop::IfcPolyLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcPolyLoop)) throw; entity = e; } +// IfcPolygonalBoundedHalfSpace +SHARED_PTR IfcPolygonalBoundedHalfSpace::Position() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +SHARED_PTR IfcPolygonalBoundedHalfSpace::PolygonalBoundary() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcPolygonalBoundedHalfSpace::is(Type::Enum v) { return v == Type::IfcPolygonalBoundedHalfSpace || IfcHalfSpaceSolid::is(v); } +Type::Enum IfcPolygonalBoundedHalfSpace::type() { return Type::IfcPolygonalBoundedHalfSpace; } +Type::Enum IfcPolygonalBoundedHalfSpace::Class() { return Type::IfcPolygonalBoundedHalfSpace; } +IfcPolygonalBoundedHalfSpace::IfcPolygonalBoundedHalfSpace(IfcAbstractEntityPtr e) { if (!is(Type::IfcPolygonalBoundedHalfSpace)) throw; entity = e; } +// IfcPolyline +SHARED_PTR< IfcTemplatedEntityList > IfcPolyline::Points() { RETURN_AS_LIST(IfcCartesianPoint,0) } +bool IfcPolyline::is(Type::Enum v) { return v == Type::IfcPolyline || IfcBoundedCurve::is(v); } +Type::Enum IfcPolyline::type() { return Type::IfcPolyline; } +Type::Enum IfcPolyline::Class() { return Type::IfcPolyline; } +IfcPolyline::IfcPolyline(IfcAbstractEntityPtr e) { if (!is(Type::IfcPolyline)) throw; entity = e; } +// IfcPort +IfcRelConnectsPortToElement::list IfcPort::ContainedIn() { RETURN_INVERSE(IfcRelConnectsPortToElement) } +IfcRelConnectsPorts::list IfcPort::ConnectedFrom() { RETURN_INVERSE(IfcRelConnectsPorts) } +IfcRelConnectsPorts::list IfcPort::ConnectedTo() { RETURN_INVERSE(IfcRelConnectsPorts) } +bool IfcPort::is(Type::Enum v) { return v == Type::IfcPort || IfcProduct::is(v); } +Type::Enum IfcPort::type() { return Type::IfcPort; } +Type::Enum IfcPort::Class() { return Type::IfcPort; } +IfcPort::IfcPort(IfcAbstractEntityPtr e) { if (!is(Type::IfcPort)) throw; entity = e; } +// IfcPostalAddress +bool IfcPostalAddress::hasInternalLocation() { return !entity->getArgument(3)->isNull(); } +IfcLabel IfcPostalAddress::InternalLocation() { return *entity->getArgument(3); } +bool IfcPostalAddress::hasAddressLines() { return !entity->getArgument(4)->isNull(); } +std::vector IfcPostalAddress::AddressLines() { return *entity->getArgument(4); } +bool IfcPostalAddress::hasPostalBox() { return !entity->getArgument(5)->isNull(); } +IfcLabel IfcPostalAddress::PostalBox() { return *entity->getArgument(5); } +bool IfcPostalAddress::hasTown() { return !entity->getArgument(6)->isNull(); } +IfcLabel IfcPostalAddress::Town() { return *entity->getArgument(6); } +bool IfcPostalAddress::hasRegion() { return !entity->getArgument(7)->isNull(); } +IfcLabel IfcPostalAddress::Region() { return *entity->getArgument(7); } +bool IfcPostalAddress::hasPostalCode() { return !entity->getArgument(8)->isNull(); } +IfcLabel IfcPostalAddress::PostalCode() { return *entity->getArgument(8); } +bool IfcPostalAddress::hasCountry() { return !entity->getArgument(9)->isNull(); } +IfcLabel IfcPostalAddress::Country() { return *entity->getArgument(9); } +bool IfcPostalAddress::is(Type::Enum v) { return v == Type::IfcPostalAddress || IfcAddress::is(v); } +Type::Enum IfcPostalAddress::type() { return Type::IfcPostalAddress; } +Type::Enum IfcPostalAddress::Class() { return Type::IfcPostalAddress; } +IfcPostalAddress::IfcPostalAddress(IfcAbstractEntityPtr e) { if (!is(Type::IfcPostalAddress)) throw; entity = e; } +// IfcPreDefinedColour +bool IfcPreDefinedColour::is(Type::Enum v) { return v == Type::IfcPreDefinedColour || IfcPreDefinedItem::is(v); } +Type::Enum IfcPreDefinedColour::type() { return Type::IfcPreDefinedColour; } +Type::Enum IfcPreDefinedColour::Class() { return Type::IfcPreDefinedColour; } +IfcPreDefinedColour::IfcPreDefinedColour(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedColour)) throw; entity = e; } +// IfcPreDefinedCurveFont +bool IfcPreDefinedCurveFont::is(Type::Enum v) { return v == Type::IfcPreDefinedCurveFont || IfcPreDefinedItem::is(v); } +Type::Enum IfcPreDefinedCurveFont::type() { return Type::IfcPreDefinedCurveFont; } +Type::Enum IfcPreDefinedCurveFont::Class() { return Type::IfcPreDefinedCurveFont; } +IfcPreDefinedCurveFont::IfcPreDefinedCurveFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedCurveFont)) throw; entity = e; } +// IfcPreDefinedDimensionSymbol +bool IfcPreDefinedDimensionSymbol::is(Type::Enum v) { return v == Type::IfcPreDefinedDimensionSymbol || IfcPreDefinedSymbol::is(v); } +Type::Enum IfcPreDefinedDimensionSymbol::type() { return Type::IfcPreDefinedDimensionSymbol; } +Type::Enum IfcPreDefinedDimensionSymbol::Class() { return Type::IfcPreDefinedDimensionSymbol; } +IfcPreDefinedDimensionSymbol::IfcPreDefinedDimensionSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedDimensionSymbol)) throw; entity = e; } +// IfcPreDefinedItem +IfcLabel IfcPreDefinedItem::Name() { return *entity->getArgument(0); } +bool IfcPreDefinedItem::is(Type::Enum v) { return v == Type::IfcPreDefinedItem; } +Type::Enum IfcPreDefinedItem::type() { return Type::IfcPreDefinedItem; } +Type::Enum IfcPreDefinedItem::Class() { return Type::IfcPreDefinedItem; } +IfcPreDefinedItem::IfcPreDefinedItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedItem)) throw; entity = e; } +// IfcPreDefinedPointMarkerSymbol +bool IfcPreDefinedPointMarkerSymbol::is(Type::Enum v) { return v == Type::IfcPreDefinedPointMarkerSymbol || IfcPreDefinedSymbol::is(v); } +Type::Enum IfcPreDefinedPointMarkerSymbol::type() { return Type::IfcPreDefinedPointMarkerSymbol; } +Type::Enum IfcPreDefinedPointMarkerSymbol::Class() { return Type::IfcPreDefinedPointMarkerSymbol; } +IfcPreDefinedPointMarkerSymbol::IfcPreDefinedPointMarkerSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedPointMarkerSymbol)) throw; entity = e; } +// IfcPreDefinedSymbol +bool IfcPreDefinedSymbol::is(Type::Enum v) { return v == Type::IfcPreDefinedSymbol || IfcPreDefinedItem::is(v); } +Type::Enum IfcPreDefinedSymbol::type() { return Type::IfcPreDefinedSymbol; } +Type::Enum IfcPreDefinedSymbol::Class() { return Type::IfcPreDefinedSymbol; } +IfcPreDefinedSymbol::IfcPreDefinedSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedSymbol)) throw; entity = e; } +// IfcPreDefinedTerminatorSymbol +bool IfcPreDefinedTerminatorSymbol::is(Type::Enum v) { return v == Type::IfcPreDefinedTerminatorSymbol || IfcPreDefinedSymbol::is(v); } +Type::Enum IfcPreDefinedTerminatorSymbol::type() { return Type::IfcPreDefinedTerminatorSymbol; } +Type::Enum IfcPreDefinedTerminatorSymbol::Class() { return Type::IfcPreDefinedTerminatorSymbol; } +IfcPreDefinedTerminatorSymbol::IfcPreDefinedTerminatorSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedTerminatorSymbol)) throw; entity = e; } +// IfcPreDefinedTextFont +bool IfcPreDefinedTextFont::is(Type::Enum v) { return v == Type::IfcPreDefinedTextFont || IfcPreDefinedItem::is(v); } +Type::Enum IfcPreDefinedTextFont::type() { return Type::IfcPreDefinedTextFont; } +Type::Enum IfcPreDefinedTextFont::Class() { return Type::IfcPreDefinedTextFont; } +IfcPreDefinedTextFont::IfcPreDefinedTextFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedTextFont)) throw; entity = e; } +// IfcPresentationLayerAssignment +IfcLabel IfcPresentationLayerAssignment::Name() { return *entity->getArgument(0); } +bool IfcPresentationLayerAssignment::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcPresentationLayerAssignment::Description() { return *entity->getArgument(1); } +SHARED_PTR< IfcTemplatedEntityList > IfcPresentationLayerAssignment::AssignedItems() { RETURN_AS_LIST(IfcAbstractSelect,2) } +bool IfcPresentationLayerAssignment::hasIdentifier() { return !entity->getArgument(3)->isNull(); } +IfcIdentifier IfcPresentationLayerAssignment::Identifier() { return *entity->getArgument(3); } +bool IfcPresentationLayerAssignment::is(Type::Enum v) { return v == Type::IfcPresentationLayerAssignment; } +Type::Enum IfcPresentationLayerAssignment::type() { return Type::IfcPresentationLayerAssignment; } +Type::Enum IfcPresentationLayerAssignment::Class() { return Type::IfcPresentationLayerAssignment; } +IfcPresentationLayerAssignment::IfcPresentationLayerAssignment(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationLayerAssignment)) throw; entity = e; } +// IfcPresentationLayerWithStyle +bool IfcPresentationLayerWithStyle::LayerOn() { return *entity->getArgument(4); } +bool IfcPresentationLayerWithStyle::LayerFrozen() { return *entity->getArgument(5); } +bool IfcPresentationLayerWithStyle::LayerBlocked() { return *entity->getArgument(6); } +SHARED_PTR< IfcTemplatedEntityList > IfcPresentationLayerWithStyle::LayerStyles() { RETURN_AS_LIST(IfcAbstractSelect,7) } +bool IfcPresentationLayerWithStyle::is(Type::Enum v) { return v == Type::IfcPresentationLayerWithStyle || IfcPresentationLayerAssignment::is(v); } +Type::Enum IfcPresentationLayerWithStyle::type() { return Type::IfcPresentationLayerWithStyle; } +Type::Enum IfcPresentationLayerWithStyle::Class() { return Type::IfcPresentationLayerWithStyle; } +IfcPresentationLayerWithStyle::IfcPresentationLayerWithStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationLayerWithStyle)) throw; entity = e; } +// IfcPresentationStyle +bool IfcPresentationStyle::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcPresentationStyle::Name() { return *entity->getArgument(0); } +bool IfcPresentationStyle::is(Type::Enum v) { return v == Type::IfcPresentationStyle; } +Type::Enum IfcPresentationStyle::type() { return Type::IfcPresentationStyle; } +Type::Enum IfcPresentationStyle::Class() { return Type::IfcPresentationStyle; } +IfcPresentationStyle::IfcPresentationStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationStyle)) throw; entity = e; } +// IfcPresentationStyleAssignment +SHARED_PTR< IfcTemplatedEntityList > IfcPresentationStyleAssignment::Styles() { RETURN_AS_LIST(IfcAbstractSelect,0) } +bool IfcPresentationStyleAssignment::is(Type::Enum v) { return v == Type::IfcPresentationStyleAssignment; } +Type::Enum IfcPresentationStyleAssignment::type() { return Type::IfcPresentationStyleAssignment; } +Type::Enum IfcPresentationStyleAssignment::Class() { return Type::IfcPresentationStyleAssignment; } +IfcPresentationStyleAssignment::IfcPresentationStyleAssignment(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationStyleAssignment)) throw; entity = e; } +// IfcProcedure +IfcIdentifier IfcProcedure::ProcedureID() { return *entity->getArgument(5); } +IfcProcedureTypeEnum::IfcProcedureTypeEnum IfcProcedure::ProcedureType() { return IfcProcedureTypeEnum::FromString(*entity->getArgument(6)); } +bool IfcProcedure::hasUserDefinedProcedureType() { return !entity->getArgument(7)->isNull(); } +IfcLabel IfcProcedure::UserDefinedProcedureType() { return *entity->getArgument(7); } +bool IfcProcedure::is(Type::Enum v) { return v == Type::IfcProcedure || IfcProcess::is(v); } +Type::Enum IfcProcedure::type() { return Type::IfcProcedure; } +Type::Enum IfcProcedure::Class() { return Type::IfcProcedure; } +IfcProcedure::IfcProcedure(IfcAbstractEntityPtr e) { if (!is(Type::IfcProcedure)) throw; entity = e; } +// IfcProcess +IfcRelAssignsToProcess::list IfcProcess::OperatesOn() { RETURN_INVERSE(IfcRelAssignsToProcess) } +IfcRelSequence::list IfcProcess::IsSuccessorFrom() { RETURN_INVERSE(IfcRelSequence) } +IfcRelSequence::list IfcProcess::IsPredecessorTo() { RETURN_INVERSE(IfcRelSequence) } +bool IfcProcess::is(Type::Enum v) { return v == Type::IfcProcess || IfcObject::is(v); } +Type::Enum IfcProcess::type() { return Type::IfcProcess; } +Type::Enum IfcProcess::Class() { return Type::IfcProcess; } +IfcProcess::IfcProcess(IfcAbstractEntityPtr e) { if (!is(Type::IfcProcess)) throw; entity = e; } +// IfcProduct +bool IfcProduct::hasObjectPlacement() { return !entity->getArgument(5)->isNull(); } +SHARED_PTR IfcProduct::ObjectPlacement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcProduct::hasRepresentation() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR IfcProduct::Representation() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +IfcRelAssignsToProduct::list IfcProduct::ReferencedBy() { RETURN_INVERSE(IfcRelAssignsToProduct) } +bool IfcProduct::is(Type::Enum v) { return v == Type::IfcProduct || IfcObject::is(v); } +Type::Enum IfcProduct::type() { return Type::IfcProduct; } +Type::Enum IfcProduct::Class() { return Type::IfcProduct; } +IfcProduct::IfcProduct(IfcAbstractEntityPtr e) { if (!is(Type::IfcProduct)) throw; entity = e; } +// IfcProductDefinitionShape +IfcProduct::list IfcProductDefinitionShape::ShapeOfProduct() { RETURN_INVERSE(IfcProduct) } +IfcShapeAspect::list IfcProductDefinitionShape::HasShapeAspects() { RETURN_INVERSE(IfcShapeAspect) } +bool IfcProductDefinitionShape::is(Type::Enum v) { return v == Type::IfcProductDefinitionShape || IfcProductRepresentation::is(v); } +Type::Enum IfcProductDefinitionShape::type() { return Type::IfcProductDefinitionShape; } +Type::Enum IfcProductDefinitionShape::Class() { return Type::IfcProductDefinitionShape; } +IfcProductDefinitionShape::IfcProductDefinitionShape(IfcAbstractEntityPtr e) { if (!is(Type::IfcProductDefinitionShape)) throw; entity = e; } +// IfcProductRepresentation +bool IfcProductRepresentation::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcProductRepresentation::Name() { return *entity->getArgument(0); } +bool IfcProductRepresentation::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcProductRepresentation::Description() { return *entity->getArgument(1); } +SHARED_PTR< IfcTemplatedEntityList > IfcProductRepresentation::Representations() { RETURN_AS_LIST(IfcRepresentation,2) } +bool IfcProductRepresentation::is(Type::Enum v) { return v == Type::IfcProductRepresentation; } +Type::Enum IfcProductRepresentation::type() { return Type::IfcProductRepresentation; } +Type::Enum IfcProductRepresentation::Class() { return Type::IfcProductRepresentation; } +IfcProductRepresentation::IfcProductRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcProductRepresentation)) throw; entity = e; } +// IfcProductsOfCombustionProperties +bool IfcProductsOfCombustionProperties::hasSpecificHeatCapacity() { return !entity->getArgument(1)->isNull(); } +IfcSpecificHeatCapacityMeasure IfcProductsOfCombustionProperties::SpecificHeatCapacity() { return *entity->getArgument(1); } +bool IfcProductsOfCombustionProperties::hasN20Content() { return !entity->getArgument(2)->isNull(); } +IfcPositiveRatioMeasure IfcProductsOfCombustionProperties::N20Content() { return *entity->getArgument(2); } +bool IfcProductsOfCombustionProperties::hasCOContent() { return !entity->getArgument(3)->isNull(); } +IfcPositiveRatioMeasure IfcProductsOfCombustionProperties::COContent() { return *entity->getArgument(3); } +bool IfcProductsOfCombustionProperties::hasCO2Content() { return !entity->getArgument(4)->isNull(); } +IfcPositiveRatioMeasure IfcProductsOfCombustionProperties::CO2Content() { return *entity->getArgument(4); } +bool IfcProductsOfCombustionProperties::is(Type::Enum v) { return v == Type::IfcProductsOfCombustionProperties || IfcMaterialProperties::is(v); } +Type::Enum IfcProductsOfCombustionProperties::type() { return Type::IfcProductsOfCombustionProperties; } +Type::Enum IfcProductsOfCombustionProperties::Class() { return Type::IfcProductsOfCombustionProperties; } +IfcProductsOfCombustionProperties::IfcProductsOfCombustionProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcProductsOfCombustionProperties)) throw; entity = e; } +// IfcProfileDef +IfcProfileTypeEnum::IfcProfileTypeEnum IfcProfileDef::ProfileType() { return IfcProfileTypeEnum::FromString(*entity->getArgument(0)); } +bool IfcProfileDef::hasProfileName() { return !entity->getArgument(1)->isNull(); } +IfcLabel IfcProfileDef::ProfileName() { return *entity->getArgument(1); } +bool IfcProfileDef::is(Type::Enum v) { return v == Type::IfcProfileDef; } +Type::Enum IfcProfileDef::type() { return Type::IfcProfileDef; } +Type::Enum IfcProfileDef::Class() { return Type::IfcProfileDef; } +IfcProfileDef::IfcProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcProfileDef)) throw; entity = e; } +// IfcProfileProperties +bool IfcProfileProperties::hasProfileName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcProfileProperties::ProfileName() { return *entity->getArgument(0); } +bool IfcProfileProperties::hasProfileDefinition() { return !entity->getArgument(1)->isNull(); } +SHARED_PTR IfcProfileProperties::ProfileDefinition() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcProfileProperties::is(Type::Enum v) { return v == Type::IfcProfileProperties; } +Type::Enum IfcProfileProperties::type() { return Type::IfcProfileProperties; } +Type::Enum IfcProfileProperties::Class() { return Type::IfcProfileProperties; } +IfcProfileProperties::IfcProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcProfileProperties)) throw; entity = e; } +// IfcProject +bool IfcProject::hasLongName() { return !entity->getArgument(5)->isNull(); } +IfcLabel IfcProject::LongName() { return *entity->getArgument(5); } +bool IfcProject::hasPhase() { return !entity->getArgument(6)->isNull(); } +IfcLabel IfcProject::Phase() { return *entity->getArgument(6); } +SHARED_PTR< IfcTemplatedEntityList > IfcProject::RepresentationContexts() { RETURN_AS_LIST(IfcRepresentationContext,7) } +SHARED_PTR IfcProject::UnitsInContext() { return reinterpret_pointer_cast(*entity->getArgument(8)); } +bool IfcProject::is(Type::Enum v) { return v == Type::IfcProject || IfcObject::is(v); } +Type::Enum IfcProject::type() { return Type::IfcProject; } +Type::Enum IfcProject::Class() { return Type::IfcProject; } +IfcProject::IfcProject(IfcAbstractEntityPtr e) { if (!is(Type::IfcProject)) throw; entity = e; } +// IfcProjectOrder +IfcIdentifier IfcProjectOrder::ID() { return *entity->getArgument(5); } +IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum IfcProjectOrder::PredefinedType() { return IfcProjectOrderTypeEnum::FromString(*entity->getArgument(6)); } +bool IfcProjectOrder::hasStatus() { return !entity->getArgument(7)->isNull(); } +IfcLabel IfcProjectOrder::Status() { return *entity->getArgument(7); } +bool IfcProjectOrder::is(Type::Enum v) { return v == Type::IfcProjectOrder || IfcControl::is(v); } +Type::Enum IfcProjectOrder::type() { return Type::IfcProjectOrder; } +Type::Enum IfcProjectOrder::Class() { return Type::IfcProjectOrder; } +IfcProjectOrder::IfcProjectOrder(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectOrder)) throw; entity = e; } +// IfcProjectOrderRecord +SHARED_PTR< IfcTemplatedEntityList > IfcProjectOrderRecord::Records() { RETURN_AS_LIST(IfcRelAssignsToProjectOrder,5) } +IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum IfcProjectOrderRecord::PredefinedType() { return IfcProjectOrderRecordTypeEnum::FromString(*entity->getArgument(6)); } +bool IfcProjectOrderRecord::is(Type::Enum v) { return v == Type::IfcProjectOrderRecord || IfcControl::is(v); } +Type::Enum IfcProjectOrderRecord::type() { return Type::IfcProjectOrderRecord; } +Type::Enum IfcProjectOrderRecord::Class() { return Type::IfcProjectOrderRecord; } +IfcProjectOrderRecord::IfcProjectOrderRecord(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectOrderRecord)) throw; entity = e; } +// IfcProjectionCurve +bool IfcProjectionCurve::is(Type::Enum v) { return v == Type::IfcProjectionCurve || IfcAnnotationCurveOccurrence::is(v); } +Type::Enum IfcProjectionCurve::type() { return Type::IfcProjectionCurve; } +Type::Enum IfcProjectionCurve::Class() { return Type::IfcProjectionCurve; } +IfcProjectionCurve::IfcProjectionCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectionCurve)) throw; entity = e; } +// IfcProjectionElement +bool IfcProjectionElement::is(Type::Enum v) { return v == Type::IfcProjectionElement || IfcFeatureElementAddition::is(v); } +Type::Enum IfcProjectionElement::type() { return Type::IfcProjectionElement; } +Type::Enum IfcProjectionElement::Class() { return Type::IfcProjectionElement; } +IfcProjectionElement::IfcProjectionElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectionElement)) throw; entity = e; } +// IfcProperty +IfcIdentifier IfcProperty::Name() { return *entity->getArgument(0); } +bool IfcProperty::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcProperty::Description() { return *entity->getArgument(1); } +IfcPropertyDependencyRelationship::list IfcProperty::PropertyForDependance() { RETURN_INVERSE(IfcPropertyDependencyRelationship) } +IfcPropertyDependencyRelationship::list IfcProperty::PropertyDependsOn() { RETURN_INVERSE(IfcPropertyDependencyRelationship) } +IfcComplexProperty::list IfcProperty::PartOfComplex() { RETURN_INVERSE(IfcComplexProperty) } +bool IfcProperty::is(Type::Enum v) { return v == Type::IfcProperty; } +Type::Enum IfcProperty::type() { return Type::IfcProperty; } +Type::Enum IfcProperty::Class() { return Type::IfcProperty; } +IfcProperty::IfcProperty(IfcAbstractEntityPtr e) { if (!is(Type::IfcProperty)) throw; entity = e; } +// IfcPropertyBoundedValue +bool IfcPropertyBoundedValue::hasUpperBoundValue() { return !entity->getArgument(2)->isNull(); } +IfcValue IfcPropertyBoundedValue::UpperBoundValue() { return *entity->getArgument(2); } +bool IfcPropertyBoundedValue::hasLowerBoundValue() { return !entity->getArgument(3)->isNull(); } +IfcValue IfcPropertyBoundedValue::LowerBoundValue() { return *entity->getArgument(3); } +bool IfcPropertyBoundedValue::hasUnit() { return !entity->getArgument(4)->isNull(); } +IfcUnit IfcPropertyBoundedValue::Unit() { return *entity->getArgument(4); } +bool IfcPropertyBoundedValue::is(Type::Enum v) { return v == Type::IfcPropertyBoundedValue || IfcSimpleProperty::is(v); } +Type::Enum IfcPropertyBoundedValue::type() { return Type::IfcPropertyBoundedValue; } +Type::Enum IfcPropertyBoundedValue::Class() { return Type::IfcPropertyBoundedValue; } +IfcPropertyBoundedValue::IfcPropertyBoundedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyBoundedValue)) throw; entity = e; } +// IfcPropertyConstraintRelationship +SHARED_PTR IfcPropertyConstraintRelationship::RelatingConstraint() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR< IfcTemplatedEntityList > IfcPropertyConstraintRelationship::RelatedProperties() { RETURN_AS_LIST(IfcProperty,1) } +bool IfcPropertyConstraintRelationship::hasName() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcPropertyConstraintRelationship::Name() { return *entity->getArgument(2); } +bool IfcPropertyConstraintRelationship::hasDescription() { return !entity->getArgument(3)->isNull(); } +IfcText IfcPropertyConstraintRelationship::Description() { return *entity->getArgument(3); } +bool IfcPropertyConstraintRelationship::is(Type::Enum v) { return v == Type::IfcPropertyConstraintRelationship; } +Type::Enum IfcPropertyConstraintRelationship::type() { return Type::IfcPropertyConstraintRelationship; } +Type::Enum IfcPropertyConstraintRelationship::Class() { return Type::IfcPropertyConstraintRelationship; } +IfcPropertyConstraintRelationship::IfcPropertyConstraintRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyConstraintRelationship)) throw; entity = e; } +// IfcPropertyDefinition +IfcRelAssociates::list IfcPropertyDefinition::HasAssociations() { RETURN_INVERSE(IfcRelAssociates) } +bool IfcPropertyDefinition::is(Type::Enum v) { return v == Type::IfcPropertyDefinition || IfcRoot::is(v); } +Type::Enum IfcPropertyDefinition::type() { return Type::IfcPropertyDefinition; } +Type::Enum IfcPropertyDefinition::Class() { return Type::IfcPropertyDefinition; } +IfcPropertyDefinition::IfcPropertyDefinition(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyDefinition)) throw; entity = e; } +// IfcPropertyDependencyRelationship +SHARED_PTR IfcPropertyDependencyRelationship::DependingProperty() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcPropertyDependencyRelationship::DependantProperty() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcPropertyDependencyRelationship::hasName() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcPropertyDependencyRelationship::Name() { return *entity->getArgument(2); } +bool IfcPropertyDependencyRelationship::hasDescription() { return !entity->getArgument(3)->isNull(); } +IfcText IfcPropertyDependencyRelationship::Description() { return *entity->getArgument(3); } +bool IfcPropertyDependencyRelationship::hasExpression() { return !entity->getArgument(4)->isNull(); } +IfcText IfcPropertyDependencyRelationship::Expression() { return *entity->getArgument(4); } +bool IfcPropertyDependencyRelationship::is(Type::Enum v) { return v == Type::IfcPropertyDependencyRelationship; } +Type::Enum IfcPropertyDependencyRelationship::type() { return Type::IfcPropertyDependencyRelationship; } +Type::Enum IfcPropertyDependencyRelationship::Class() { return Type::IfcPropertyDependencyRelationship; } +IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyDependencyRelationship)) throw; entity = e; } +// IfcPropertyEnumeratedValue +SHARED_PTR< IfcTemplatedEntityList > IfcPropertyEnumeratedValue::EnumerationValues() { RETURN_AS_LIST(IfcAbstractSelect,2) } +bool IfcPropertyEnumeratedValue::hasEnumerationReference() { return !entity->getArgument(3)->isNull(); } +SHARED_PTR IfcPropertyEnumeratedValue::EnumerationReference() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcPropertyEnumeratedValue::is(Type::Enum v) { return v == Type::IfcPropertyEnumeratedValue || IfcSimpleProperty::is(v); } +Type::Enum IfcPropertyEnumeratedValue::type() { return Type::IfcPropertyEnumeratedValue; } +Type::Enum IfcPropertyEnumeratedValue::Class() { return Type::IfcPropertyEnumeratedValue; } +IfcPropertyEnumeratedValue::IfcPropertyEnumeratedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyEnumeratedValue)) throw; entity = e; } +// IfcPropertyEnumeration +IfcLabel IfcPropertyEnumeration::Name() { return *entity->getArgument(0); } +SHARED_PTR< IfcTemplatedEntityList > IfcPropertyEnumeration::EnumerationValues() { RETURN_AS_LIST(IfcAbstractSelect,1) } +bool IfcPropertyEnumeration::hasUnit() { return !entity->getArgument(2)->isNull(); } +IfcUnit IfcPropertyEnumeration::Unit() { return *entity->getArgument(2); } +bool IfcPropertyEnumeration::is(Type::Enum v) { return v == Type::IfcPropertyEnumeration; } +Type::Enum IfcPropertyEnumeration::type() { return Type::IfcPropertyEnumeration; } +Type::Enum IfcPropertyEnumeration::Class() { return Type::IfcPropertyEnumeration; } +IfcPropertyEnumeration::IfcPropertyEnumeration(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyEnumeration)) throw; entity = e; } +// IfcPropertyListValue +SHARED_PTR< IfcTemplatedEntityList > IfcPropertyListValue::ListValues() { RETURN_AS_LIST(IfcAbstractSelect,2) } +bool IfcPropertyListValue::hasUnit() { return !entity->getArgument(3)->isNull(); } +IfcUnit IfcPropertyListValue::Unit() { return *entity->getArgument(3); } +bool IfcPropertyListValue::is(Type::Enum v) { return v == Type::IfcPropertyListValue || IfcSimpleProperty::is(v); } +Type::Enum IfcPropertyListValue::type() { return Type::IfcPropertyListValue; } +Type::Enum IfcPropertyListValue::Class() { return Type::IfcPropertyListValue; } +IfcPropertyListValue::IfcPropertyListValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyListValue)) throw; entity = e; } +// IfcPropertyReferenceValue +bool IfcPropertyReferenceValue::hasUsageName() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcPropertyReferenceValue::UsageName() { return *entity->getArgument(2); } +IfcObjectReferenceSelect IfcPropertyReferenceValue::PropertyReference() { return *entity->getArgument(3); } +bool IfcPropertyReferenceValue::is(Type::Enum v) { return v == Type::IfcPropertyReferenceValue || IfcSimpleProperty::is(v); } +Type::Enum IfcPropertyReferenceValue::type() { return Type::IfcPropertyReferenceValue; } +Type::Enum IfcPropertyReferenceValue::Class() { return Type::IfcPropertyReferenceValue; } +IfcPropertyReferenceValue::IfcPropertyReferenceValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyReferenceValue)) throw; entity = e; } +// IfcPropertySet +SHARED_PTR< IfcTemplatedEntityList > IfcPropertySet::HasProperties() { RETURN_AS_LIST(IfcProperty,4) } +bool IfcPropertySet::is(Type::Enum v) { return v == Type::IfcPropertySet || IfcPropertySetDefinition::is(v); } +Type::Enum IfcPropertySet::type() { return Type::IfcPropertySet; } +Type::Enum IfcPropertySet::Class() { return Type::IfcPropertySet; } +IfcPropertySet::IfcPropertySet(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertySet)) throw; entity = e; } +// IfcPropertySetDefinition +IfcRelDefinesByProperties::list IfcPropertySetDefinition::PropertyDefinitionOf() { RETURN_INVERSE(IfcRelDefinesByProperties) } +IfcTypeObject::list IfcPropertySetDefinition::DefinesType() { RETURN_INVERSE(IfcTypeObject) } +bool IfcPropertySetDefinition::is(Type::Enum v) { return v == Type::IfcPropertySetDefinition || IfcPropertyDefinition::is(v); } +Type::Enum IfcPropertySetDefinition::type() { return Type::IfcPropertySetDefinition; } +Type::Enum IfcPropertySetDefinition::Class() { return Type::IfcPropertySetDefinition; } +IfcPropertySetDefinition::IfcPropertySetDefinition(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertySetDefinition)) throw; entity = e; } +// IfcPropertySingleValue +bool IfcPropertySingleValue::hasNominalValue() { return !entity->getArgument(2)->isNull(); } +IfcValue IfcPropertySingleValue::NominalValue() { return *entity->getArgument(2); } +bool IfcPropertySingleValue::hasUnit() { return !entity->getArgument(3)->isNull(); } +IfcUnit IfcPropertySingleValue::Unit() { return *entity->getArgument(3); } +bool IfcPropertySingleValue::is(Type::Enum v) { return v == Type::IfcPropertySingleValue || IfcSimpleProperty::is(v); } +Type::Enum IfcPropertySingleValue::type() { return Type::IfcPropertySingleValue; } +Type::Enum IfcPropertySingleValue::Class() { return Type::IfcPropertySingleValue; } +IfcPropertySingleValue::IfcPropertySingleValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertySingleValue)) throw; entity = e; } +// IfcPropertyTableValue +SHARED_PTR< IfcTemplatedEntityList > IfcPropertyTableValue::DefiningValues() { RETURN_AS_LIST(IfcAbstractSelect,2) } +SHARED_PTR< IfcTemplatedEntityList > IfcPropertyTableValue::DefinedValues() { RETURN_AS_LIST(IfcAbstractSelect,3) } +bool IfcPropertyTableValue::hasExpression() { return !entity->getArgument(4)->isNull(); } +IfcText IfcPropertyTableValue::Expression() { return *entity->getArgument(4); } +bool IfcPropertyTableValue::hasDefiningUnit() { return !entity->getArgument(5)->isNull(); } +IfcUnit IfcPropertyTableValue::DefiningUnit() { return *entity->getArgument(5); } +bool IfcPropertyTableValue::hasDefinedUnit() { return !entity->getArgument(6)->isNull(); } +IfcUnit IfcPropertyTableValue::DefinedUnit() { return *entity->getArgument(6); } +bool IfcPropertyTableValue::is(Type::Enum v) { return v == Type::IfcPropertyTableValue || IfcSimpleProperty::is(v); } +Type::Enum IfcPropertyTableValue::type() { return Type::IfcPropertyTableValue; } +Type::Enum IfcPropertyTableValue::Class() { return Type::IfcPropertyTableValue; } +IfcPropertyTableValue::IfcPropertyTableValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyTableValue)) throw; entity = e; } +// IfcProtectiveDeviceType +IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum IfcProtectiveDeviceType::PredefinedType() { return IfcProtectiveDeviceTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcProtectiveDeviceType::is(Type::Enum v) { return v == Type::IfcProtectiveDeviceType || IfcFlowControllerType::is(v); } +Type::Enum IfcProtectiveDeviceType::type() { return Type::IfcProtectiveDeviceType; } +Type::Enum IfcProtectiveDeviceType::Class() { return Type::IfcProtectiveDeviceType; } +IfcProtectiveDeviceType::IfcProtectiveDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcProtectiveDeviceType)) throw; entity = e; } +// IfcProxy +IfcObjectTypeEnum::IfcObjectTypeEnum IfcProxy::ProxyType() { return IfcObjectTypeEnum::FromString(*entity->getArgument(7)); } +bool IfcProxy::hasTag() { return !entity->getArgument(8)->isNull(); } +IfcLabel IfcProxy::Tag() { return *entity->getArgument(8); } +bool IfcProxy::is(Type::Enum v) { return v == Type::IfcProxy || IfcProduct::is(v); } +Type::Enum IfcProxy::type() { return Type::IfcProxy; } +Type::Enum IfcProxy::Class() { return Type::IfcProxy; } +IfcProxy::IfcProxy(IfcAbstractEntityPtr e) { if (!is(Type::IfcProxy)) throw; entity = e; } +// IfcPumpType +IfcPumpTypeEnum::IfcPumpTypeEnum IfcPumpType::PredefinedType() { return IfcPumpTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcPumpType::is(Type::Enum v) { return v == Type::IfcPumpType || IfcFlowMovingDeviceType::is(v); } +Type::Enum IfcPumpType::type() { return Type::IfcPumpType; } +Type::Enum IfcPumpType::Class() { return Type::IfcPumpType; } +IfcPumpType::IfcPumpType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPumpType)) throw; entity = e; } +// IfcQuantityArea +IfcAreaMeasure IfcQuantityArea::AreaValue() { return *entity->getArgument(3); } +bool IfcQuantityArea::is(Type::Enum v) { return v == Type::IfcQuantityArea || IfcPhysicalSimpleQuantity::is(v); } +Type::Enum IfcQuantityArea::type() { return Type::IfcQuantityArea; } +Type::Enum IfcQuantityArea::Class() { return Type::IfcQuantityArea; } +IfcQuantityArea::IfcQuantityArea(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityArea)) throw; entity = e; } +// IfcQuantityCount +IfcCountMeasure IfcQuantityCount::CountValue() { return *entity->getArgument(3); } +bool IfcQuantityCount::is(Type::Enum v) { return v == Type::IfcQuantityCount || IfcPhysicalSimpleQuantity::is(v); } +Type::Enum IfcQuantityCount::type() { return Type::IfcQuantityCount; } +Type::Enum IfcQuantityCount::Class() { return Type::IfcQuantityCount; } +IfcQuantityCount::IfcQuantityCount(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityCount)) throw; entity = e; } +// IfcQuantityLength +IfcLengthMeasure IfcQuantityLength::LengthValue() { return *entity->getArgument(3); } +bool IfcQuantityLength::is(Type::Enum v) { return v == Type::IfcQuantityLength || IfcPhysicalSimpleQuantity::is(v); } +Type::Enum IfcQuantityLength::type() { return Type::IfcQuantityLength; } +Type::Enum IfcQuantityLength::Class() { return Type::IfcQuantityLength; } +IfcQuantityLength::IfcQuantityLength(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityLength)) throw; entity = e; } +// IfcQuantityTime +IfcTimeMeasure IfcQuantityTime::TimeValue() { return *entity->getArgument(3); } +bool IfcQuantityTime::is(Type::Enum v) { return v == Type::IfcQuantityTime || IfcPhysicalSimpleQuantity::is(v); } +Type::Enum IfcQuantityTime::type() { return Type::IfcQuantityTime; } +Type::Enum IfcQuantityTime::Class() { return Type::IfcQuantityTime; } +IfcQuantityTime::IfcQuantityTime(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityTime)) throw; entity = e; } +// IfcQuantityVolume +IfcVolumeMeasure IfcQuantityVolume::VolumeValue() { return *entity->getArgument(3); } +bool IfcQuantityVolume::is(Type::Enum v) { return v == Type::IfcQuantityVolume || IfcPhysicalSimpleQuantity::is(v); } +Type::Enum IfcQuantityVolume::type() { return Type::IfcQuantityVolume; } +Type::Enum IfcQuantityVolume::Class() { return Type::IfcQuantityVolume; } +IfcQuantityVolume::IfcQuantityVolume(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityVolume)) throw; entity = e; } +// IfcQuantityWeight +IfcMassMeasure IfcQuantityWeight::WeightValue() { return *entity->getArgument(3); } +bool IfcQuantityWeight::is(Type::Enum v) { return v == Type::IfcQuantityWeight || IfcPhysicalSimpleQuantity::is(v); } +Type::Enum IfcQuantityWeight::type() { return Type::IfcQuantityWeight; } +Type::Enum IfcQuantityWeight::Class() { return Type::IfcQuantityWeight; } +IfcQuantityWeight::IfcQuantityWeight(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityWeight)) throw; entity = e; } +// IfcRadiusDimension +bool IfcRadiusDimension::is(Type::Enum v) { return v == Type::IfcRadiusDimension || IfcDimensionCurveDirectedCallout::is(v); } +Type::Enum IfcRadiusDimension::type() { return Type::IfcRadiusDimension; } +Type::Enum IfcRadiusDimension::Class() { return Type::IfcRadiusDimension; } +IfcRadiusDimension::IfcRadiusDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcRadiusDimension)) throw; entity = e; } +// IfcRailing +bool IfcRailing::hasPredefinedType() { return !entity->getArgument(8)->isNull(); } +IfcRailingTypeEnum::IfcRailingTypeEnum IfcRailing::PredefinedType() { return IfcRailingTypeEnum::FromString(*entity->getArgument(8)); } +bool IfcRailing::is(Type::Enum v) { return v == Type::IfcRailing || IfcBuildingElement::is(v); } +Type::Enum IfcRailing::type() { return Type::IfcRailing; } +Type::Enum IfcRailing::Class() { return Type::IfcRailing; } +IfcRailing::IfcRailing(IfcAbstractEntityPtr e) { if (!is(Type::IfcRailing)) throw; entity = e; } +// IfcRailingType +IfcRailingTypeEnum::IfcRailingTypeEnum IfcRailingType::PredefinedType() { return IfcRailingTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcRailingType::is(Type::Enum v) { return v == Type::IfcRailingType || IfcBuildingElementType::is(v); } +Type::Enum IfcRailingType::type() { return Type::IfcRailingType; } +Type::Enum IfcRailingType::Class() { return Type::IfcRailingType; } +IfcRailingType::IfcRailingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcRailingType)) throw; entity = e; } +// IfcRamp +IfcRampTypeEnum::IfcRampTypeEnum IfcRamp::ShapeType() { return IfcRampTypeEnum::FromString(*entity->getArgument(8)); } +bool IfcRamp::is(Type::Enum v) { return v == Type::IfcRamp || IfcBuildingElement::is(v); } +Type::Enum IfcRamp::type() { return Type::IfcRamp; } +Type::Enum IfcRamp::Class() { return Type::IfcRamp; } +IfcRamp::IfcRamp(IfcAbstractEntityPtr e) { if (!is(Type::IfcRamp)) throw; entity = e; } +// IfcRampFlight +bool IfcRampFlight::is(Type::Enum v) { return v == Type::IfcRampFlight || IfcBuildingElement::is(v); } +Type::Enum IfcRampFlight::type() { return Type::IfcRampFlight; } +Type::Enum IfcRampFlight::Class() { return Type::IfcRampFlight; } +IfcRampFlight::IfcRampFlight(IfcAbstractEntityPtr e) { if (!is(Type::IfcRampFlight)) throw; entity = e; } +// IfcRampFlightType +IfcRampFlightTypeEnum::IfcRampFlightTypeEnum IfcRampFlightType::PredefinedType() { return IfcRampFlightTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcRampFlightType::is(Type::Enum v) { return v == Type::IfcRampFlightType || IfcBuildingElementType::is(v); } +Type::Enum IfcRampFlightType::type() { return Type::IfcRampFlightType; } +Type::Enum IfcRampFlightType::Class() { return Type::IfcRampFlightType; } +IfcRampFlightType::IfcRampFlightType(IfcAbstractEntityPtr e) { if (!is(Type::IfcRampFlightType)) throw; entity = e; } +// IfcRationalBezierCurve +std::vector IfcRationalBezierCurve::WeightsData() { return *entity->getArgument(5); } +bool IfcRationalBezierCurve::is(Type::Enum v) { return v == Type::IfcRationalBezierCurve || IfcBezierCurve::is(v); } +Type::Enum IfcRationalBezierCurve::type() { return Type::IfcRationalBezierCurve; } +Type::Enum IfcRationalBezierCurve::Class() { return Type::IfcRationalBezierCurve; } +IfcRationalBezierCurve::IfcRationalBezierCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcRationalBezierCurve)) throw; entity = e; } +// IfcRectangleHollowProfileDef +IfcPositiveLengthMeasure IfcRectangleHollowProfileDef::WallThickness() { return *entity->getArgument(5); } +bool IfcRectangleHollowProfileDef::hasInnerFilletRadius() { return !entity->getArgument(6)->isNull(); } +IfcPositiveLengthMeasure IfcRectangleHollowProfileDef::InnerFilletRadius() { return *entity->getArgument(6); } +bool IfcRectangleHollowProfileDef::hasOuterFilletRadius() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcRectangleHollowProfileDef::OuterFilletRadius() { return *entity->getArgument(7); } +bool IfcRectangleHollowProfileDef::is(Type::Enum v) { return v == Type::IfcRectangleHollowProfileDef || IfcRectangleProfileDef::is(v); } +Type::Enum IfcRectangleHollowProfileDef::type() { return Type::IfcRectangleHollowProfileDef; } +Type::Enum IfcRectangleHollowProfileDef::Class() { return Type::IfcRectangleHollowProfileDef; } +IfcRectangleHollowProfileDef::IfcRectangleHollowProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangleHollowProfileDef)) throw; entity = e; } +// IfcRectangleProfileDef +IfcPositiveLengthMeasure IfcRectangleProfileDef::XDim() { return *entity->getArgument(3); } +IfcPositiveLengthMeasure IfcRectangleProfileDef::YDim() { return *entity->getArgument(4); } +bool IfcRectangleProfileDef::is(Type::Enum v) { return v == Type::IfcRectangleProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcRectangleProfileDef::type() { return Type::IfcRectangleProfileDef; } +Type::Enum IfcRectangleProfileDef::Class() { return Type::IfcRectangleProfileDef; } +IfcRectangleProfileDef::IfcRectangleProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangleProfileDef)) throw; entity = e; } +// IfcRectangularPyramid +IfcPositiveLengthMeasure IfcRectangularPyramid::XLength() { return *entity->getArgument(1); } +IfcPositiveLengthMeasure IfcRectangularPyramid::YLength() { return *entity->getArgument(2); } +IfcPositiveLengthMeasure IfcRectangularPyramid::Height() { return *entity->getArgument(3); } +bool IfcRectangularPyramid::is(Type::Enum v) { return v == Type::IfcRectangularPyramid || IfcCsgPrimitive3D::is(v); } +Type::Enum IfcRectangularPyramid::type() { return Type::IfcRectangularPyramid; } +Type::Enum IfcRectangularPyramid::Class() { return Type::IfcRectangularPyramid; } +IfcRectangularPyramid::IfcRectangularPyramid(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangularPyramid)) throw; entity = e; } +// IfcRectangularTrimmedSurface +SHARED_PTR IfcRectangularTrimmedSurface::BasisSurface() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcParameterValue IfcRectangularTrimmedSurface::U1() { return *entity->getArgument(1); } +IfcParameterValue IfcRectangularTrimmedSurface::V1() { return *entity->getArgument(2); } +IfcParameterValue IfcRectangularTrimmedSurface::U2() { return *entity->getArgument(3); } +IfcParameterValue IfcRectangularTrimmedSurface::V2() { return *entity->getArgument(4); } +bool IfcRectangularTrimmedSurface::Usense() { return *entity->getArgument(5); } +bool IfcRectangularTrimmedSurface::Vsense() { return *entity->getArgument(6); } +bool IfcRectangularTrimmedSurface::is(Type::Enum v) { return v == Type::IfcRectangularTrimmedSurface || IfcBoundedSurface::is(v); } +Type::Enum IfcRectangularTrimmedSurface::type() { return Type::IfcRectangularTrimmedSurface; } +Type::Enum IfcRectangularTrimmedSurface::Class() { return Type::IfcRectangularTrimmedSurface; } +IfcRectangularTrimmedSurface::IfcRectangularTrimmedSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangularTrimmedSurface)) throw; entity = e; } +// IfcReferencesValueDocument +IfcDocumentSelect IfcReferencesValueDocument::ReferencedDocument() { return *entity->getArgument(0); } +SHARED_PTR< IfcTemplatedEntityList > IfcReferencesValueDocument::ReferencingValues() { RETURN_AS_LIST(IfcAppliedValue,1) } +bool IfcReferencesValueDocument::hasName() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcReferencesValueDocument::Name() { return *entity->getArgument(2); } +bool IfcReferencesValueDocument::hasDescription() { return !entity->getArgument(3)->isNull(); } +IfcText IfcReferencesValueDocument::Description() { return *entity->getArgument(3); } +bool IfcReferencesValueDocument::is(Type::Enum v) { return v == Type::IfcReferencesValueDocument; } +Type::Enum IfcReferencesValueDocument::type() { return Type::IfcReferencesValueDocument; } +Type::Enum IfcReferencesValueDocument::Class() { return Type::IfcReferencesValueDocument; } +IfcReferencesValueDocument::IfcReferencesValueDocument(IfcAbstractEntityPtr e) { if (!is(Type::IfcReferencesValueDocument)) throw; entity = e; } +// IfcRegularTimeSeries +IfcTimeMeasure IfcRegularTimeSeries::TimeStep() { return *entity->getArgument(8); } +SHARED_PTR< IfcTemplatedEntityList > IfcRegularTimeSeries::Values() { RETURN_AS_LIST(IfcTimeSeriesValue,9) } +bool IfcRegularTimeSeries::is(Type::Enum v) { return v == Type::IfcRegularTimeSeries || IfcTimeSeries::is(v); } +Type::Enum IfcRegularTimeSeries::type() { return Type::IfcRegularTimeSeries; } +Type::Enum IfcRegularTimeSeries::Class() { return Type::IfcRegularTimeSeries; } +IfcRegularTimeSeries::IfcRegularTimeSeries(IfcAbstractEntityPtr e) { if (!is(Type::IfcRegularTimeSeries)) throw; entity = e; } +// IfcReinforcementBarProperties +IfcAreaMeasure IfcReinforcementBarProperties::TotalCrossSectionArea() { return *entity->getArgument(0); } +IfcLabel IfcReinforcementBarProperties::SteelGrade() { return *entity->getArgument(1); } +bool IfcReinforcementBarProperties::hasBarSurface() { return !entity->getArgument(2)->isNull(); } +IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcementBarProperties::BarSurface() { return IfcReinforcingBarSurfaceEnum::FromString(*entity->getArgument(2)); } +bool IfcReinforcementBarProperties::hasEffectiveDepth() { return !entity->getArgument(3)->isNull(); } +IfcLengthMeasure IfcReinforcementBarProperties::EffectiveDepth() { return *entity->getArgument(3); } +bool IfcReinforcementBarProperties::hasNominalBarDiameter() { return !entity->getArgument(4)->isNull(); } +IfcPositiveLengthMeasure IfcReinforcementBarProperties::NominalBarDiameter() { return *entity->getArgument(4); } +bool IfcReinforcementBarProperties::hasBarCount() { return !entity->getArgument(5)->isNull(); } +IfcCountMeasure IfcReinforcementBarProperties::BarCount() { return *entity->getArgument(5); } +bool IfcReinforcementBarProperties::is(Type::Enum v) { return v == Type::IfcReinforcementBarProperties; } +Type::Enum IfcReinforcementBarProperties::type() { return Type::IfcReinforcementBarProperties; } +Type::Enum IfcReinforcementBarProperties::Class() { return Type::IfcReinforcementBarProperties; } +IfcReinforcementBarProperties::IfcReinforcementBarProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcementBarProperties)) throw; entity = e; } +// IfcReinforcementDefinitionProperties +bool IfcReinforcementDefinitionProperties::hasDefinitionType() { return !entity->getArgument(4)->isNull(); } +IfcLabel IfcReinforcementDefinitionProperties::DefinitionType() { return *entity->getArgument(4); } +SHARED_PTR< IfcTemplatedEntityList > IfcReinforcementDefinitionProperties::ReinforcementSectionDefinitions() { RETURN_AS_LIST(IfcSectionReinforcementProperties,5) } +bool IfcReinforcementDefinitionProperties::is(Type::Enum v) { return v == Type::IfcReinforcementDefinitionProperties || IfcPropertySetDefinition::is(v); } +Type::Enum IfcReinforcementDefinitionProperties::type() { return Type::IfcReinforcementDefinitionProperties; } +Type::Enum IfcReinforcementDefinitionProperties::Class() { return Type::IfcReinforcementDefinitionProperties; } +IfcReinforcementDefinitionProperties::IfcReinforcementDefinitionProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcementDefinitionProperties)) throw; entity = e; } +// IfcReinforcingBar +IfcPositiveLengthMeasure IfcReinforcingBar::NominalDiameter() { return *entity->getArgument(9); } +IfcAreaMeasure IfcReinforcingBar::CrossSectionArea() { return *entity->getArgument(10); } +bool IfcReinforcingBar::hasBarLength() { return !entity->getArgument(11)->isNull(); } +IfcPositiveLengthMeasure IfcReinforcingBar::BarLength() { return *entity->getArgument(11); } +IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum IfcReinforcingBar::BarRole() { return IfcReinforcingBarRoleEnum::FromString(*entity->getArgument(12)); } +bool IfcReinforcingBar::hasBarSurface() { return !entity->getArgument(13)->isNull(); } +IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcingBar::BarSurface() { return IfcReinforcingBarSurfaceEnum::FromString(*entity->getArgument(13)); } +bool IfcReinforcingBar::is(Type::Enum v) { return v == Type::IfcReinforcingBar || IfcReinforcingElement::is(v); } +Type::Enum IfcReinforcingBar::type() { return Type::IfcReinforcingBar; } +Type::Enum IfcReinforcingBar::Class() { return Type::IfcReinforcingBar; } +IfcReinforcingBar::IfcReinforcingBar(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcingBar)) throw; entity = e; } +// IfcReinforcingElement +bool IfcReinforcingElement::hasSteelGrade() { return !entity->getArgument(8)->isNull(); } +IfcLabel IfcReinforcingElement::SteelGrade() { return *entity->getArgument(8); } +bool IfcReinforcingElement::is(Type::Enum v) { return v == Type::IfcReinforcingElement || IfcBuildingElementComponent::is(v); } +Type::Enum IfcReinforcingElement::type() { return Type::IfcReinforcingElement; } +Type::Enum IfcReinforcingElement::Class() { return Type::IfcReinforcingElement; } +IfcReinforcingElement::IfcReinforcingElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcingElement)) throw; entity = e; } +// IfcReinforcingMesh +bool IfcReinforcingMesh::hasMeshLength() { return !entity->getArgument(9)->isNull(); } +IfcPositiveLengthMeasure IfcReinforcingMesh::MeshLength() { return *entity->getArgument(9); } +bool IfcReinforcingMesh::hasMeshWidth() { return !entity->getArgument(10)->isNull(); } +IfcPositiveLengthMeasure IfcReinforcingMesh::MeshWidth() { return *entity->getArgument(10); } +IfcPositiveLengthMeasure IfcReinforcingMesh::LongitudinalBarNominalDiameter() { return *entity->getArgument(11); } +IfcPositiveLengthMeasure IfcReinforcingMesh::TransverseBarNominalDiameter() { return *entity->getArgument(12); } +IfcAreaMeasure IfcReinforcingMesh::LongitudinalBarCrossSectionArea() { return *entity->getArgument(13); } +IfcAreaMeasure IfcReinforcingMesh::TransverseBarCrossSectionArea() { return *entity->getArgument(14); } +IfcPositiveLengthMeasure IfcReinforcingMesh::LongitudinalBarSpacing() { return *entity->getArgument(15); } +IfcPositiveLengthMeasure IfcReinforcingMesh::TransverseBarSpacing() { return *entity->getArgument(16); } +bool IfcReinforcingMesh::is(Type::Enum v) { return v == Type::IfcReinforcingMesh || IfcReinforcingElement::is(v); } +Type::Enum IfcReinforcingMesh::type() { return Type::IfcReinforcingMesh; } +Type::Enum IfcReinforcingMesh::Class() { return Type::IfcReinforcingMesh; } +IfcReinforcingMesh::IfcReinforcingMesh(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcingMesh)) throw; entity = e; } +// IfcRelAggregates +bool IfcRelAggregates::is(Type::Enum v) { return v == Type::IfcRelAggregates || IfcRelDecomposes::is(v); } +Type::Enum IfcRelAggregates::type() { return Type::IfcRelAggregates; } +Type::Enum IfcRelAggregates::Class() { return Type::IfcRelAggregates; } +IfcRelAggregates::IfcRelAggregates(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAggregates)) throw; entity = e; } +// IfcRelAssigns +SHARED_PTR< IfcTemplatedEntityList > IfcRelAssigns::RelatedObjects() { RETURN_AS_LIST(IfcObjectDefinition,4) } +bool IfcRelAssigns::hasRelatedObjectsType() { return !entity->getArgument(5)->isNull(); } +IfcObjectTypeEnum::IfcObjectTypeEnum IfcRelAssigns::RelatedObjectsType() { return IfcObjectTypeEnum::FromString(*entity->getArgument(5)); } +bool IfcRelAssigns::is(Type::Enum v) { return v == Type::IfcRelAssigns || IfcRelationship::is(v); } +Type::Enum IfcRelAssigns::type() { return Type::IfcRelAssigns; } +Type::Enum IfcRelAssigns::Class() { return Type::IfcRelAssigns; } +IfcRelAssigns::IfcRelAssigns(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssigns)) throw; entity = e; } +// IfcRelAssignsTasks +bool IfcRelAssignsTasks::hasTimeForTask() { return !entity->getArgument(7)->isNull(); } +SHARED_PTR IfcRelAssignsTasks::TimeForTask() { return reinterpret_pointer_cast(*entity->getArgument(7)); } +bool IfcRelAssignsTasks::is(Type::Enum v) { return v == Type::IfcRelAssignsTasks || IfcRelAssignsToControl::is(v); } +Type::Enum IfcRelAssignsTasks::type() { return Type::IfcRelAssignsTasks; } +Type::Enum IfcRelAssignsTasks::Class() { return Type::IfcRelAssignsTasks; } +IfcRelAssignsTasks::IfcRelAssignsTasks(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsTasks)) throw; entity = e; } +// IfcRelAssignsToActor +SHARED_PTR IfcRelAssignsToActor::RelatingActor() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcRelAssignsToActor::hasActingRole() { return !entity->getArgument(7)->isNull(); } +SHARED_PTR IfcRelAssignsToActor::ActingRole() { return reinterpret_pointer_cast(*entity->getArgument(7)); } +bool IfcRelAssignsToActor::is(Type::Enum v) { return v == Type::IfcRelAssignsToActor || IfcRelAssigns::is(v); } +Type::Enum IfcRelAssignsToActor::type() { return Type::IfcRelAssignsToActor; } +Type::Enum IfcRelAssignsToActor::Class() { return Type::IfcRelAssignsToActor; } +IfcRelAssignsToActor::IfcRelAssignsToActor(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToActor)) throw; entity = e; } +// IfcRelAssignsToControl +SHARED_PTR IfcRelAssignsToControl::RelatingControl() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcRelAssignsToControl::is(Type::Enum v) { return v == Type::IfcRelAssignsToControl || IfcRelAssigns::is(v); } +Type::Enum IfcRelAssignsToControl::type() { return Type::IfcRelAssignsToControl; } +Type::Enum IfcRelAssignsToControl::Class() { return Type::IfcRelAssignsToControl; } +IfcRelAssignsToControl::IfcRelAssignsToControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToControl)) throw; entity = e; } +// IfcRelAssignsToGroup +SHARED_PTR IfcRelAssignsToGroup::RelatingGroup() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcRelAssignsToGroup::is(Type::Enum v) { return v == Type::IfcRelAssignsToGroup || IfcRelAssigns::is(v); } +Type::Enum IfcRelAssignsToGroup::type() { return Type::IfcRelAssignsToGroup; } +Type::Enum IfcRelAssignsToGroup::Class() { return Type::IfcRelAssignsToGroup; } +IfcRelAssignsToGroup::IfcRelAssignsToGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToGroup)) throw; entity = e; } +// IfcRelAssignsToProcess +SHARED_PTR IfcRelAssignsToProcess::RelatingProcess() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcRelAssignsToProcess::hasQuantityInProcess() { return !entity->getArgument(7)->isNull(); } +SHARED_PTR IfcRelAssignsToProcess::QuantityInProcess() { return reinterpret_pointer_cast(*entity->getArgument(7)); } +bool IfcRelAssignsToProcess::is(Type::Enum v) { return v == Type::IfcRelAssignsToProcess || IfcRelAssigns::is(v); } +Type::Enum IfcRelAssignsToProcess::type() { return Type::IfcRelAssignsToProcess; } +Type::Enum IfcRelAssignsToProcess::Class() { return Type::IfcRelAssignsToProcess; } +IfcRelAssignsToProcess::IfcRelAssignsToProcess(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToProcess)) throw; entity = e; } +// IfcRelAssignsToProduct +SHARED_PTR IfcRelAssignsToProduct::RelatingProduct() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcRelAssignsToProduct::is(Type::Enum v) { return v == Type::IfcRelAssignsToProduct || IfcRelAssigns::is(v); } +Type::Enum IfcRelAssignsToProduct::type() { return Type::IfcRelAssignsToProduct; } +Type::Enum IfcRelAssignsToProduct::Class() { return Type::IfcRelAssignsToProduct; } +IfcRelAssignsToProduct::IfcRelAssignsToProduct(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToProduct)) throw; entity = e; } +// IfcRelAssignsToProjectOrder +bool IfcRelAssignsToProjectOrder::is(Type::Enum v) { return v == Type::IfcRelAssignsToProjectOrder || IfcRelAssignsToControl::is(v); } +Type::Enum IfcRelAssignsToProjectOrder::type() { return Type::IfcRelAssignsToProjectOrder; } +Type::Enum IfcRelAssignsToProjectOrder::Class() { return Type::IfcRelAssignsToProjectOrder; } +IfcRelAssignsToProjectOrder::IfcRelAssignsToProjectOrder(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToProjectOrder)) throw; entity = e; } +// IfcRelAssignsToResource +SHARED_PTR IfcRelAssignsToResource::RelatingResource() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcRelAssignsToResource::is(Type::Enum v) { return v == Type::IfcRelAssignsToResource || IfcRelAssigns::is(v); } +Type::Enum IfcRelAssignsToResource::type() { return Type::IfcRelAssignsToResource; } +Type::Enum IfcRelAssignsToResource::Class() { return Type::IfcRelAssignsToResource; } +IfcRelAssignsToResource::IfcRelAssignsToResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToResource)) throw; entity = e; } +// IfcRelAssociates +SHARED_PTR< IfcTemplatedEntityList > IfcRelAssociates::RelatedObjects() { RETURN_AS_LIST(IfcRoot,4) } +bool IfcRelAssociates::is(Type::Enum v) { return v == Type::IfcRelAssociates || IfcRelationship::is(v); } +Type::Enum IfcRelAssociates::type() { return Type::IfcRelAssociates; } +Type::Enum IfcRelAssociates::Class() { return Type::IfcRelAssociates; } +IfcRelAssociates::IfcRelAssociates(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociates)) throw; entity = e; } +// IfcRelAssociatesAppliedValue +SHARED_PTR IfcRelAssociatesAppliedValue::RelatingAppliedValue() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelAssociatesAppliedValue::is(Type::Enum v) { return v == Type::IfcRelAssociatesAppliedValue || IfcRelAssociates::is(v); } +Type::Enum IfcRelAssociatesAppliedValue::type() { return Type::IfcRelAssociatesAppliedValue; } +Type::Enum IfcRelAssociatesAppliedValue::Class() { return Type::IfcRelAssociatesAppliedValue; } +IfcRelAssociatesAppliedValue::IfcRelAssociatesAppliedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesAppliedValue)) throw; entity = e; } +// IfcRelAssociatesApproval +SHARED_PTR IfcRelAssociatesApproval::RelatingApproval() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelAssociatesApproval::is(Type::Enum v) { return v == Type::IfcRelAssociatesApproval || IfcRelAssociates::is(v); } +Type::Enum IfcRelAssociatesApproval::type() { return Type::IfcRelAssociatesApproval; } +Type::Enum IfcRelAssociatesApproval::Class() { return Type::IfcRelAssociatesApproval; } +IfcRelAssociatesApproval::IfcRelAssociatesApproval(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesApproval)) throw; entity = e; } +// IfcRelAssociatesClassification +IfcClassificationNotationSelect IfcRelAssociatesClassification::RelatingClassification() { return *entity->getArgument(5); } +bool IfcRelAssociatesClassification::is(Type::Enum v) { return v == Type::IfcRelAssociatesClassification || IfcRelAssociates::is(v); } +Type::Enum IfcRelAssociatesClassification::type() { return Type::IfcRelAssociatesClassification; } +Type::Enum IfcRelAssociatesClassification::Class() { return Type::IfcRelAssociatesClassification; } +IfcRelAssociatesClassification::IfcRelAssociatesClassification(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesClassification)) throw; entity = e; } +// IfcRelAssociatesConstraint +IfcLabel IfcRelAssociatesConstraint::Intent() { return *entity->getArgument(5); } +SHARED_PTR IfcRelAssociatesConstraint::RelatingConstraint() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcRelAssociatesConstraint::is(Type::Enum v) { return v == Type::IfcRelAssociatesConstraint || IfcRelAssociates::is(v); } +Type::Enum IfcRelAssociatesConstraint::type() { return Type::IfcRelAssociatesConstraint; } +Type::Enum IfcRelAssociatesConstraint::Class() { return Type::IfcRelAssociatesConstraint; } +IfcRelAssociatesConstraint::IfcRelAssociatesConstraint(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesConstraint)) throw; entity = e; } +// IfcRelAssociatesDocument +IfcDocumentSelect IfcRelAssociatesDocument::RelatingDocument() { return *entity->getArgument(5); } +bool IfcRelAssociatesDocument::is(Type::Enum v) { return v == Type::IfcRelAssociatesDocument || IfcRelAssociates::is(v); } +Type::Enum IfcRelAssociatesDocument::type() { return Type::IfcRelAssociatesDocument; } +Type::Enum IfcRelAssociatesDocument::Class() { return Type::IfcRelAssociatesDocument; } +IfcRelAssociatesDocument::IfcRelAssociatesDocument(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesDocument)) throw; entity = e; } +// IfcRelAssociatesLibrary +IfcLibrarySelect IfcRelAssociatesLibrary::RelatingLibrary() { return *entity->getArgument(5); } +bool IfcRelAssociatesLibrary::is(Type::Enum v) { return v == Type::IfcRelAssociatesLibrary || IfcRelAssociates::is(v); } +Type::Enum IfcRelAssociatesLibrary::type() { return Type::IfcRelAssociatesLibrary; } +Type::Enum IfcRelAssociatesLibrary::Class() { return Type::IfcRelAssociatesLibrary; } +IfcRelAssociatesLibrary::IfcRelAssociatesLibrary(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesLibrary)) throw; entity = e; } +// IfcRelAssociatesMaterial +IfcMaterialSelect IfcRelAssociatesMaterial::RelatingMaterial() { return *entity->getArgument(5); } +bool IfcRelAssociatesMaterial::is(Type::Enum v) { return v == Type::IfcRelAssociatesMaterial || IfcRelAssociates::is(v); } +Type::Enum IfcRelAssociatesMaterial::type() { return Type::IfcRelAssociatesMaterial; } +Type::Enum IfcRelAssociatesMaterial::Class() { return Type::IfcRelAssociatesMaterial; } +IfcRelAssociatesMaterial::IfcRelAssociatesMaterial(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesMaterial)) throw; entity = e; } +// IfcRelAssociatesProfileProperties +SHARED_PTR IfcRelAssociatesProfileProperties::RelatingProfileProperties() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelAssociatesProfileProperties::hasProfileSectionLocation() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR IfcRelAssociatesProfileProperties::ProfileSectionLocation() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcRelAssociatesProfileProperties::hasProfileOrientation() { return !entity->getArgument(7)->isNull(); } +IfcOrientationSelect IfcRelAssociatesProfileProperties::ProfileOrientation() { return *entity->getArgument(7); } +bool IfcRelAssociatesProfileProperties::is(Type::Enum v) { return v == Type::IfcRelAssociatesProfileProperties || IfcRelAssociates::is(v); } +Type::Enum IfcRelAssociatesProfileProperties::type() { return Type::IfcRelAssociatesProfileProperties; } +Type::Enum IfcRelAssociatesProfileProperties::Class() { return Type::IfcRelAssociatesProfileProperties; } +IfcRelAssociatesProfileProperties::IfcRelAssociatesProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesProfileProperties)) throw; entity = e; } +// IfcRelConnects +bool IfcRelConnects::is(Type::Enum v) { return v == Type::IfcRelConnects || IfcRelationship::is(v); } +Type::Enum IfcRelConnects::type() { return Type::IfcRelConnects; } +Type::Enum IfcRelConnects::Class() { return Type::IfcRelConnects; } +IfcRelConnects::IfcRelConnects(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnects)) throw; entity = e; } +// IfcRelConnectsElements +bool IfcRelConnectsElements::hasConnectionGeometry() { return !entity->getArgument(4)->isNull(); } +SHARED_PTR IfcRelConnectsElements::ConnectionGeometry() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR IfcRelConnectsElements::RelatingElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +SHARED_PTR IfcRelConnectsElements::RelatedElement() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcRelConnectsElements::is(Type::Enum v) { return v == Type::IfcRelConnectsElements || IfcRelConnects::is(v); } +Type::Enum IfcRelConnectsElements::type() { return Type::IfcRelConnectsElements; } +Type::Enum IfcRelConnectsElements::Class() { return Type::IfcRelConnectsElements; } +IfcRelConnectsElements::IfcRelConnectsElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsElements)) throw; entity = e; } +// IfcRelConnectsPathElements +std::vector IfcRelConnectsPathElements::RelatingPriorities() { return *entity->getArgument(7); } +std::vector IfcRelConnectsPathElements::RelatedPriorities() { return *entity->getArgument(8); } +IfcConnectionTypeEnum::IfcConnectionTypeEnum IfcRelConnectsPathElements::RelatedConnectionType() { return IfcConnectionTypeEnum::FromString(*entity->getArgument(9)); } +IfcConnectionTypeEnum::IfcConnectionTypeEnum IfcRelConnectsPathElements::RelatingConnectionType() { return IfcConnectionTypeEnum::FromString(*entity->getArgument(10)); } +bool IfcRelConnectsPathElements::is(Type::Enum v) { return v == Type::IfcRelConnectsPathElements || IfcRelConnectsElements::is(v); } +Type::Enum IfcRelConnectsPathElements::type() { return Type::IfcRelConnectsPathElements; } +Type::Enum IfcRelConnectsPathElements::Class() { return Type::IfcRelConnectsPathElements; } +IfcRelConnectsPathElements::IfcRelConnectsPathElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsPathElements)) throw; entity = e; } +// IfcRelConnectsPortToElement +SHARED_PTR IfcRelConnectsPortToElement::RelatingPort() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR IfcRelConnectsPortToElement::RelatedElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelConnectsPortToElement::is(Type::Enum v) { return v == Type::IfcRelConnectsPortToElement || IfcRelConnects::is(v); } +Type::Enum IfcRelConnectsPortToElement::type() { return Type::IfcRelConnectsPortToElement; } +Type::Enum IfcRelConnectsPortToElement::Class() { return Type::IfcRelConnectsPortToElement; } +IfcRelConnectsPortToElement::IfcRelConnectsPortToElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsPortToElement)) throw; entity = e; } +// IfcRelConnectsPorts +SHARED_PTR IfcRelConnectsPorts::RelatingPort() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR IfcRelConnectsPorts::RelatedPort() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelConnectsPorts::hasRealizingElement() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR IfcRelConnectsPorts::RealizingElement() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcRelConnectsPorts::is(Type::Enum v) { return v == Type::IfcRelConnectsPorts || IfcRelConnects::is(v); } +Type::Enum IfcRelConnectsPorts::type() { return Type::IfcRelConnectsPorts; } +Type::Enum IfcRelConnectsPorts::Class() { return Type::IfcRelConnectsPorts; } +IfcRelConnectsPorts::IfcRelConnectsPorts(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsPorts)) throw; entity = e; } +// IfcRelConnectsStructuralActivity +IfcStructuralActivityAssignmentSelect IfcRelConnectsStructuralActivity::RelatingElement() { return *entity->getArgument(4); } +SHARED_PTR IfcRelConnectsStructuralActivity::RelatedStructuralActivity() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelConnectsStructuralActivity::is(Type::Enum v) { return v == Type::IfcRelConnectsStructuralActivity || IfcRelConnects::is(v); } +Type::Enum IfcRelConnectsStructuralActivity::type() { return Type::IfcRelConnectsStructuralActivity; } +Type::Enum IfcRelConnectsStructuralActivity::Class() { return Type::IfcRelConnectsStructuralActivity; } +IfcRelConnectsStructuralActivity::IfcRelConnectsStructuralActivity(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsStructuralActivity)) throw; entity = e; } +// IfcRelConnectsStructuralElement +SHARED_PTR IfcRelConnectsStructuralElement::RelatingElement() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR IfcRelConnectsStructuralElement::RelatedStructuralMember() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelConnectsStructuralElement::is(Type::Enum v) { return v == Type::IfcRelConnectsStructuralElement || IfcRelConnects::is(v); } +Type::Enum IfcRelConnectsStructuralElement::type() { return Type::IfcRelConnectsStructuralElement; } +Type::Enum IfcRelConnectsStructuralElement::Class() { return Type::IfcRelConnectsStructuralElement; } +IfcRelConnectsStructuralElement::IfcRelConnectsStructuralElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsStructuralElement)) throw; entity = e; } +// IfcRelConnectsStructuralMember +SHARED_PTR IfcRelConnectsStructuralMember::RelatingStructuralMember() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR IfcRelConnectsStructuralMember::RelatedStructuralConnection() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelConnectsStructuralMember::hasAppliedCondition() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR IfcRelConnectsStructuralMember::AppliedCondition() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcRelConnectsStructuralMember::hasAdditionalConditions() { return !entity->getArgument(7)->isNull(); } +SHARED_PTR IfcRelConnectsStructuralMember::AdditionalConditions() { return reinterpret_pointer_cast(*entity->getArgument(7)); } +bool IfcRelConnectsStructuralMember::hasSupportedLength() { return !entity->getArgument(8)->isNull(); } +IfcLengthMeasure IfcRelConnectsStructuralMember::SupportedLength() { return *entity->getArgument(8); } +bool IfcRelConnectsStructuralMember::hasConditionCoordinateSystem() { return !entity->getArgument(9)->isNull(); } +SHARED_PTR IfcRelConnectsStructuralMember::ConditionCoordinateSystem() { return reinterpret_pointer_cast(*entity->getArgument(9)); } +bool IfcRelConnectsStructuralMember::is(Type::Enum v) { return v == Type::IfcRelConnectsStructuralMember || IfcRelConnects::is(v); } +Type::Enum IfcRelConnectsStructuralMember::type() { return Type::IfcRelConnectsStructuralMember; } +Type::Enum IfcRelConnectsStructuralMember::Class() { return Type::IfcRelConnectsStructuralMember; } +IfcRelConnectsStructuralMember::IfcRelConnectsStructuralMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsStructuralMember)) throw; entity = e; } +// IfcRelConnectsWithEccentricity +SHARED_PTR IfcRelConnectsWithEccentricity::ConnectionConstraint() { return reinterpret_pointer_cast(*entity->getArgument(10)); } +bool IfcRelConnectsWithEccentricity::is(Type::Enum v) { return v == Type::IfcRelConnectsWithEccentricity || IfcRelConnectsStructuralMember::is(v); } +Type::Enum IfcRelConnectsWithEccentricity::type() { return Type::IfcRelConnectsWithEccentricity; } +Type::Enum IfcRelConnectsWithEccentricity::Class() { return Type::IfcRelConnectsWithEccentricity; } +IfcRelConnectsWithEccentricity::IfcRelConnectsWithEccentricity(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsWithEccentricity)) throw; entity = e; } +// IfcRelConnectsWithRealizingElements +SHARED_PTR< IfcTemplatedEntityList > IfcRelConnectsWithRealizingElements::RealizingElements() { RETURN_AS_LIST(IfcElement,7) } +bool IfcRelConnectsWithRealizingElements::hasConnectionType() { return !entity->getArgument(8)->isNull(); } +IfcLabel IfcRelConnectsWithRealizingElements::ConnectionType() { return *entity->getArgument(8); } +bool IfcRelConnectsWithRealizingElements::is(Type::Enum v) { return v == Type::IfcRelConnectsWithRealizingElements || IfcRelConnectsElements::is(v); } +Type::Enum IfcRelConnectsWithRealizingElements::type() { return Type::IfcRelConnectsWithRealizingElements; } +Type::Enum IfcRelConnectsWithRealizingElements::Class() { return Type::IfcRelConnectsWithRealizingElements; } +IfcRelConnectsWithRealizingElements::IfcRelConnectsWithRealizingElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsWithRealizingElements)) throw; entity = e; } +// IfcRelContainedInSpatialStructure +SHARED_PTR< IfcTemplatedEntityList > IfcRelContainedInSpatialStructure::RelatedElements() { RETURN_AS_LIST(IfcProduct,4) } +SHARED_PTR IfcRelContainedInSpatialStructure::RelatingStructure() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelContainedInSpatialStructure::is(Type::Enum v) { return v == Type::IfcRelContainedInSpatialStructure || IfcRelConnects::is(v); } +Type::Enum IfcRelContainedInSpatialStructure::type() { return Type::IfcRelContainedInSpatialStructure; } +Type::Enum IfcRelContainedInSpatialStructure::Class() { return Type::IfcRelContainedInSpatialStructure; } +IfcRelContainedInSpatialStructure::IfcRelContainedInSpatialStructure(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelContainedInSpatialStructure)) throw; entity = e; } +// IfcRelCoversBldgElements +SHARED_PTR IfcRelCoversBldgElements::RelatingBuildingElement() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR< IfcTemplatedEntityList > IfcRelCoversBldgElements::RelatedCoverings() { RETURN_AS_LIST(IfcCovering,5) } +bool IfcRelCoversBldgElements::is(Type::Enum v) { return v == Type::IfcRelCoversBldgElements || IfcRelConnects::is(v); } +Type::Enum IfcRelCoversBldgElements::type() { return Type::IfcRelCoversBldgElements; } +Type::Enum IfcRelCoversBldgElements::Class() { return Type::IfcRelCoversBldgElements; } +IfcRelCoversBldgElements::IfcRelCoversBldgElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelCoversBldgElements)) throw; entity = e; } +// IfcRelCoversSpaces +SHARED_PTR IfcRelCoversSpaces::RelatedSpace() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR< IfcTemplatedEntityList > IfcRelCoversSpaces::RelatedCoverings() { RETURN_AS_LIST(IfcCovering,5) } +bool IfcRelCoversSpaces::is(Type::Enum v) { return v == Type::IfcRelCoversSpaces || IfcRelConnects::is(v); } +Type::Enum IfcRelCoversSpaces::type() { return Type::IfcRelCoversSpaces; } +Type::Enum IfcRelCoversSpaces::Class() { return Type::IfcRelCoversSpaces; } +IfcRelCoversSpaces::IfcRelCoversSpaces(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelCoversSpaces)) throw; entity = e; } +// IfcRelDecomposes +SHARED_PTR IfcRelDecomposes::RelatingObject() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR< IfcTemplatedEntityList > IfcRelDecomposes::RelatedObjects() { RETURN_AS_LIST(IfcObjectDefinition,5) } +bool IfcRelDecomposes::is(Type::Enum v) { return v == Type::IfcRelDecomposes || IfcRelationship::is(v); } +Type::Enum IfcRelDecomposes::type() { return Type::IfcRelDecomposes; } +Type::Enum IfcRelDecomposes::Class() { return Type::IfcRelDecomposes; } +IfcRelDecomposes::IfcRelDecomposes(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDecomposes)) throw; entity = e; } +// IfcRelDefines +SHARED_PTR< IfcTemplatedEntityList > IfcRelDefines::RelatedObjects() { RETURN_AS_LIST(IfcObject,4) } +bool IfcRelDefines::is(Type::Enum v) { return v == Type::IfcRelDefines || IfcRelationship::is(v); } +Type::Enum IfcRelDefines::type() { return Type::IfcRelDefines; } +Type::Enum IfcRelDefines::Class() { return Type::IfcRelDefines; } +IfcRelDefines::IfcRelDefines(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDefines)) throw; entity = e; } +// IfcRelDefinesByProperties +SHARED_PTR IfcRelDefinesByProperties::RelatingPropertyDefinition() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelDefinesByProperties::is(Type::Enum v) { return v == Type::IfcRelDefinesByProperties || IfcRelDefines::is(v); } +Type::Enum IfcRelDefinesByProperties::type() { return Type::IfcRelDefinesByProperties; } +Type::Enum IfcRelDefinesByProperties::Class() { return Type::IfcRelDefinesByProperties; } +IfcRelDefinesByProperties::IfcRelDefinesByProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDefinesByProperties)) throw; entity = e; } +// IfcRelDefinesByType +SHARED_PTR IfcRelDefinesByType::RelatingType() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelDefinesByType::is(Type::Enum v) { return v == Type::IfcRelDefinesByType || IfcRelDefines::is(v); } +Type::Enum IfcRelDefinesByType::type() { return Type::IfcRelDefinesByType; } +Type::Enum IfcRelDefinesByType::Class() { return Type::IfcRelDefinesByType; } +IfcRelDefinesByType::IfcRelDefinesByType(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDefinesByType)) throw; entity = e; } +// IfcRelFillsElement +SHARED_PTR IfcRelFillsElement::RelatingOpeningElement() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR IfcRelFillsElement::RelatedBuildingElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelFillsElement::is(Type::Enum v) { return v == Type::IfcRelFillsElement || IfcRelConnects::is(v); } +Type::Enum IfcRelFillsElement::type() { return Type::IfcRelFillsElement; } +Type::Enum IfcRelFillsElement::Class() { return Type::IfcRelFillsElement; } +IfcRelFillsElement::IfcRelFillsElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelFillsElement)) throw; entity = e; } +// IfcRelFlowControlElements +SHARED_PTR< IfcTemplatedEntityList > IfcRelFlowControlElements::RelatedControlElements() { RETURN_AS_LIST(IfcDistributionControlElement,4) } +SHARED_PTR IfcRelFlowControlElements::RelatingFlowElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelFlowControlElements::is(Type::Enum v) { return v == Type::IfcRelFlowControlElements || IfcRelConnects::is(v); } +Type::Enum IfcRelFlowControlElements::type() { return Type::IfcRelFlowControlElements; } +Type::Enum IfcRelFlowControlElements::Class() { return Type::IfcRelFlowControlElements; } +IfcRelFlowControlElements::IfcRelFlowControlElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelFlowControlElements)) throw; entity = e; } +// IfcRelInteractionRequirements +bool IfcRelInteractionRequirements::hasDailyInteraction() { return !entity->getArgument(4)->isNull(); } +IfcCountMeasure IfcRelInteractionRequirements::DailyInteraction() { return *entity->getArgument(4); } +bool IfcRelInteractionRequirements::hasImportanceRating() { return !entity->getArgument(5)->isNull(); } +IfcNormalisedRatioMeasure IfcRelInteractionRequirements::ImportanceRating() { return *entity->getArgument(5); } +bool IfcRelInteractionRequirements::hasLocationOfInteraction() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR IfcRelInteractionRequirements::LocationOfInteraction() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +SHARED_PTR IfcRelInteractionRequirements::RelatedSpaceProgram() { return reinterpret_pointer_cast(*entity->getArgument(7)); } +SHARED_PTR IfcRelInteractionRequirements::RelatingSpaceProgram() { return reinterpret_pointer_cast(*entity->getArgument(8)); } +bool IfcRelInteractionRequirements::is(Type::Enum v) { return v == Type::IfcRelInteractionRequirements || IfcRelConnects::is(v); } +Type::Enum IfcRelInteractionRequirements::type() { return Type::IfcRelInteractionRequirements; } +Type::Enum IfcRelInteractionRequirements::Class() { return Type::IfcRelInteractionRequirements; } +IfcRelInteractionRequirements::IfcRelInteractionRequirements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelInteractionRequirements)) throw; entity = e; } +// IfcRelNests +bool IfcRelNests::is(Type::Enum v) { return v == Type::IfcRelNests || IfcRelDecomposes::is(v); } +Type::Enum IfcRelNests::type() { return Type::IfcRelNests; } +Type::Enum IfcRelNests::Class() { return Type::IfcRelNests; } +IfcRelNests::IfcRelNests(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelNests)) throw; entity = e; } +// IfcRelOccupiesSpaces +bool IfcRelOccupiesSpaces::is(Type::Enum v) { return v == Type::IfcRelOccupiesSpaces || IfcRelAssignsToActor::is(v); } +Type::Enum IfcRelOccupiesSpaces::type() { return Type::IfcRelOccupiesSpaces; } +Type::Enum IfcRelOccupiesSpaces::Class() { return Type::IfcRelOccupiesSpaces; } +IfcRelOccupiesSpaces::IfcRelOccupiesSpaces(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelOccupiesSpaces)) throw; entity = e; } +// IfcRelOverridesProperties +SHARED_PTR< IfcTemplatedEntityList > IfcRelOverridesProperties::OverridingProperties() { RETURN_AS_LIST(IfcProperty,6) } +bool IfcRelOverridesProperties::is(Type::Enum v) { return v == Type::IfcRelOverridesProperties || IfcRelDefinesByProperties::is(v); } +Type::Enum IfcRelOverridesProperties::type() { return Type::IfcRelOverridesProperties; } +Type::Enum IfcRelOverridesProperties::Class() { return Type::IfcRelOverridesProperties; } +IfcRelOverridesProperties::IfcRelOverridesProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelOverridesProperties)) throw; entity = e; } +// IfcRelProjectsElement +SHARED_PTR IfcRelProjectsElement::RelatingElement() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR IfcRelProjectsElement::RelatedFeatureElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelProjectsElement::is(Type::Enum v) { return v == Type::IfcRelProjectsElement || IfcRelConnects::is(v); } +Type::Enum IfcRelProjectsElement::type() { return Type::IfcRelProjectsElement; } +Type::Enum IfcRelProjectsElement::Class() { return Type::IfcRelProjectsElement; } +IfcRelProjectsElement::IfcRelProjectsElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelProjectsElement)) throw; entity = e; } +// IfcRelReferencedInSpatialStructure +SHARED_PTR< IfcTemplatedEntityList > IfcRelReferencedInSpatialStructure::RelatedElements() { RETURN_AS_LIST(IfcProduct,4) } +SHARED_PTR IfcRelReferencedInSpatialStructure::RelatingStructure() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelReferencedInSpatialStructure::is(Type::Enum v) { return v == Type::IfcRelReferencedInSpatialStructure || IfcRelConnects::is(v); } +Type::Enum IfcRelReferencedInSpatialStructure::type() { return Type::IfcRelReferencedInSpatialStructure; } +Type::Enum IfcRelReferencedInSpatialStructure::Class() { return Type::IfcRelReferencedInSpatialStructure; } +IfcRelReferencedInSpatialStructure::IfcRelReferencedInSpatialStructure(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelReferencedInSpatialStructure)) throw; entity = e; } +// IfcRelSchedulesCostItems +bool IfcRelSchedulesCostItems::is(Type::Enum v) { return v == Type::IfcRelSchedulesCostItems || IfcRelAssignsToControl::is(v); } +Type::Enum IfcRelSchedulesCostItems::type() { return Type::IfcRelSchedulesCostItems; } +Type::Enum IfcRelSchedulesCostItems::Class() { return Type::IfcRelSchedulesCostItems; } +IfcRelSchedulesCostItems::IfcRelSchedulesCostItems(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelSchedulesCostItems)) throw; entity = e; } +// IfcRelSequence +SHARED_PTR IfcRelSequence::RelatingProcess() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR IfcRelSequence::RelatedProcess() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +IfcTimeMeasure IfcRelSequence::TimeLag() { return *entity->getArgument(6); } +IfcSequenceEnum::IfcSequenceEnum IfcRelSequence::SequenceType() { return IfcSequenceEnum::FromString(*entity->getArgument(7)); } +bool IfcRelSequence::is(Type::Enum v) { return v == Type::IfcRelSequence || IfcRelConnects::is(v); } +Type::Enum IfcRelSequence::type() { return Type::IfcRelSequence; } +Type::Enum IfcRelSequence::Class() { return Type::IfcRelSequence; } +IfcRelSequence::IfcRelSequence(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelSequence)) throw; entity = e; } +// IfcRelServicesBuildings +SHARED_PTR IfcRelServicesBuildings::RelatingSystem() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR< IfcTemplatedEntityList > IfcRelServicesBuildings::RelatedBuildings() { RETURN_AS_LIST(IfcSpatialStructureElement,5) } +bool IfcRelServicesBuildings::is(Type::Enum v) { return v == Type::IfcRelServicesBuildings || IfcRelConnects::is(v); } +Type::Enum IfcRelServicesBuildings::type() { return Type::IfcRelServicesBuildings; } +Type::Enum IfcRelServicesBuildings::Class() { return Type::IfcRelServicesBuildings; } +IfcRelServicesBuildings::IfcRelServicesBuildings(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelServicesBuildings)) throw; entity = e; } +// IfcRelSpaceBoundary +SHARED_PTR IfcRelSpaceBoundary::RelatingSpace() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +bool IfcRelSpaceBoundary::hasRelatedBuildingElement() { return !entity->getArgument(5)->isNull(); } +SHARED_PTR IfcRelSpaceBoundary::RelatedBuildingElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelSpaceBoundary::hasConnectionGeometry() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR IfcRelSpaceBoundary::ConnectionGeometry() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum IfcRelSpaceBoundary::PhysicalOrVirtualBoundary() { return IfcPhysicalOrVirtualEnum::FromString(*entity->getArgument(7)); } +IfcInternalOrExternalEnum::IfcInternalOrExternalEnum IfcRelSpaceBoundary::InternalOrExternalBoundary() { return IfcInternalOrExternalEnum::FromString(*entity->getArgument(8)); } +bool IfcRelSpaceBoundary::is(Type::Enum v) { return v == Type::IfcRelSpaceBoundary || IfcRelConnects::is(v); } +Type::Enum IfcRelSpaceBoundary::type() { return Type::IfcRelSpaceBoundary; } +Type::Enum IfcRelSpaceBoundary::Class() { return Type::IfcRelSpaceBoundary; } +IfcRelSpaceBoundary::IfcRelSpaceBoundary(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelSpaceBoundary)) throw; entity = e; } +// IfcRelVoidsElement +SHARED_PTR IfcRelVoidsElement::RelatingBuildingElement() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR IfcRelVoidsElement::RelatedOpeningElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcRelVoidsElement::is(Type::Enum v) { return v == Type::IfcRelVoidsElement || IfcRelConnects::is(v); } +Type::Enum IfcRelVoidsElement::type() { return Type::IfcRelVoidsElement; } +Type::Enum IfcRelVoidsElement::Class() { return Type::IfcRelVoidsElement; } +IfcRelVoidsElement::IfcRelVoidsElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelVoidsElement)) throw; entity = e; } +// IfcRelationship +bool IfcRelationship::is(Type::Enum v) { return v == Type::IfcRelationship || IfcRoot::is(v); } +Type::Enum IfcRelationship::type() { return Type::IfcRelationship; } +Type::Enum IfcRelationship::Class() { return Type::IfcRelationship; } +IfcRelationship::IfcRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelationship)) throw; entity = e; } +// IfcRelaxation +IfcNormalisedRatioMeasure IfcRelaxation::RelaxationValue() { return *entity->getArgument(0); } +IfcNormalisedRatioMeasure IfcRelaxation::InitialStress() { return *entity->getArgument(1); } +bool IfcRelaxation::is(Type::Enum v) { return v == Type::IfcRelaxation; } +Type::Enum IfcRelaxation::type() { return Type::IfcRelaxation; } +Type::Enum IfcRelaxation::Class() { return Type::IfcRelaxation; } +IfcRelaxation::IfcRelaxation(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelaxation)) throw; entity = e; } +// IfcRepresentation +SHARED_PTR IfcRepresentation::ContextOfItems() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcRepresentation::hasRepresentationIdentifier() { return !entity->getArgument(1)->isNull(); } +IfcLabel IfcRepresentation::RepresentationIdentifier() { return *entity->getArgument(1); } +bool IfcRepresentation::hasRepresentationType() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcRepresentation::RepresentationType() { return *entity->getArgument(2); } +SHARED_PTR< IfcTemplatedEntityList > IfcRepresentation::Items() { RETURN_AS_LIST(IfcRepresentationItem,3) } +IfcRepresentationMap::list IfcRepresentation::RepresentationMap() { RETURN_INVERSE(IfcRepresentationMap) } +IfcPresentationLayerAssignment::list IfcRepresentation::LayerAssignments() { RETURN_INVERSE(IfcPresentationLayerAssignment) } +IfcProductRepresentation::list IfcRepresentation::OfProductRepresentation() { RETURN_INVERSE(IfcProductRepresentation) } +bool IfcRepresentation::is(Type::Enum v) { return v == Type::IfcRepresentation; } +Type::Enum IfcRepresentation::type() { return Type::IfcRepresentation; } +Type::Enum IfcRepresentation::Class() { return Type::IfcRepresentation; } +IfcRepresentation::IfcRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentation)) throw; entity = e; } +// IfcRepresentationContext +bool IfcRepresentationContext::hasContextIdentifier() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcRepresentationContext::ContextIdentifier() { return *entity->getArgument(0); } +bool IfcRepresentationContext::hasContextType() { return !entity->getArgument(1)->isNull(); } +IfcLabel IfcRepresentationContext::ContextType() { return *entity->getArgument(1); } +IfcRepresentation::list IfcRepresentationContext::RepresentationsInContext() { RETURN_INVERSE(IfcRepresentation) } +bool IfcRepresentationContext::is(Type::Enum v) { return v == Type::IfcRepresentationContext; } +Type::Enum IfcRepresentationContext::type() { return Type::IfcRepresentationContext; } +Type::Enum IfcRepresentationContext::Class() { return Type::IfcRepresentationContext; } +IfcRepresentationContext::IfcRepresentationContext(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentationContext)) throw; entity = e; } +// IfcRepresentationItem +IfcPresentationLayerAssignment::list IfcRepresentationItem::LayerAssignments() { RETURN_INVERSE(IfcPresentationLayerAssignment) } +IfcStyledItem::list IfcRepresentationItem::StyledByItem() { RETURN_INVERSE(IfcStyledItem) } +bool IfcRepresentationItem::is(Type::Enum v) { return v == Type::IfcRepresentationItem; } +Type::Enum IfcRepresentationItem::type() { return Type::IfcRepresentationItem; } +Type::Enum IfcRepresentationItem::Class() { return Type::IfcRepresentationItem; } +IfcRepresentationItem::IfcRepresentationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentationItem)) throw; entity = e; } +// IfcRepresentationMap +IfcAxis2Placement IfcRepresentationMap::MappingOrigin() { return *entity->getArgument(0); } +SHARED_PTR IfcRepresentationMap::MappedRepresentation() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +IfcMappedItem::list IfcRepresentationMap::MapUsage() { RETURN_INVERSE(IfcMappedItem) } +bool IfcRepresentationMap::is(Type::Enum v) { return v == Type::IfcRepresentationMap; } +Type::Enum IfcRepresentationMap::type() { return Type::IfcRepresentationMap; } +Type::Enum IfcRepresentationMap::Class() { return Type::IfcRepresentationMap; } +IfcRepresentationMap::IfcRepresentationMap(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentationMap)) throw; entity = e; } +// IfcResource +IfcRelAssignsToResource::list IfcResource::ResourceOf() { RETURN_INVERSE(IfcRelAssignsToResource) } +bool IfcResource::is(Type::Enum v) { return v == Type::IfcResource || IfcObject::is(v); } +Type::Enum IfcResource::type() { return Type::IfcResource; } +Type::Enum IfcResource::Class() { return Type::IfcResource; } +IfcResource::IfcResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcResource)) throw; entity = e; } +// IfcRevolvedAreaSolid +SHARED_PTR IfcRevolvedAreaSolid::Axis() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +IfcPlaneAngleMeasure IfcRevolvedAreaSolid::Angle() { return *entity->getArgument(3); } +bool IfcRevolvedAreaSolid::is(Type::Enum v) { return v == Type::IfcRevolvedAreaSolid || IfcSweptAreaSolid::is(v); } +Type::Enum IfcRevolvedAreaSolid::type() { return Type::IfcRevolvedAreaSolid; } +Type::Enum IfcRevolvedAreaSolid::Class() { return Type::IfcRevolvedAreaSolid; } +IfcRevolvedAreaSolid::IfcRevolvedAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcRevolvedAreaSolid)) throw; entity = e; } +// IfcRibPlateProfileProperties +bool IfcRibPlateProfileProperties::hasThickness() { return !entity->getArgument(2)->isNull(); } +IfcPositiveLengthMeasure IfcRibPlateProfileProperties::Thickness() { return *entity->getArgument(2); } +bool IfcRibPlateProfileProperties::hasRibHeight() { return !entity->getArgument(3)->isNull(); } +IfcPositiveLengthMeasure IfcRibPlateProfileProperties::RibHeight() { return *entity->getArgument(3); } +bool IfcRibPlateProfileProperties::hasRibWidth() { return !entity->getArgument(4)->isNull(); } +IfcPositiveLengthMeasure IfcRibPlateProfileProperties::RibWidth() { return *entity->getArgument(4); } +bool IfcRibPlateProfileProperties::hasRibSpacing() { return !entity->getArgument(5)->isNull(); } +IfcPositiveLengthMeasure IfcRibPlateProfileProperties::RibSpacing() { return *entity->getArgument(5); } +IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum IfcRibPlateProfileProperties::Direction() { return IfcRibPlateDirectionEnum::FromString(*entity->getArgument(6)); } +bool IfcRibPlateProfileProperties::is(Type::Enum v) { return v == Type::IfcRibPlateProfileProperties || IfcProfileProperties::is(v); } +Type::Enum IfcRibPlateProfileProperties::type() { return Type::IfcRibPlateProfileProperties; } +Type::Enum IfcRibPlateProfileProperties::Class() { return Type::IfcRibPlateProfileProperties; } +IfcRibPlateProfileProperties::IfcRibPlateProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRibPlateProfileProperties)) throw; entity = e; } +// IfcRightCircularCone +IfcPositiveLengthMeasure IfcRightCircularCone::Height() { return *entity->getArgument(1); } +IfcPositiveLengthMeasure IfcRightCircularCone::BottomRadius() { return *entity->getArgument(2); } +bool IfcRightCircularCone::is(Type::Enum v) { return v == Type::IfcRightCircularCone || IfcCsgPrimitive3D::is(v); } +Type::Enum IfcRightCircularCone::type() { return Type::IfcRightCircularCone; } +Type::Enum IfcRightCircularCone::Class() { return Type::IfcRightCircularCone; } +IfcRightCircularCone::IfcRightCircularCone(IfcAbstractEntityPtr e) { if (!is(Type::IfcRightCircularCone)) throw; entity = e; } +// IfcRightCircularCylinder +IfcPositiveLengthMeasure IfcRightCircularCylinder::Height() { return *entity->getArgument(1); } +IfcPositiveLengthMeasure IfcRightCircularCylinder::Radius() { return *entity->getArgument(2); } +bool IfcRightCircularCylinder::is(Type::Enum v) { return v == Type::IfcRightCircularCylinder || IfcCsgPrimitive3D::is(v); } +Type::Enum IfcRightCircularCylinder::type() { return Type::IfcRightCircularCylinder; } +Type::Enum IfcRightCircularCylinder::Class() { return Type::IfcRightCircularCylinder; } +IfcRightCircularCylinder::IfcRightCircularCylinder(IfcAbstractEntityPtr e) { if (!is(Type::IfcRightCircularCylinder)) throw; entity = e; } +// IfcRoof +IfcRoofTypeEnum::IfcRoofTypeEnum IfcRoof::ShapeType() { return IfcRoofTypeEnum::FromString(*entity->getArgument(8)); } +bool IfcRoof::is(Type::Enum v) { return v == Type::IfcRoof || IfcBuildingElement::is(v); } +Type::Enum IfcRoof::type() { return Type::IfcRoof; } +Type::Enum IfcRoof::Class() { return Type::IfcRoof; } +IfcRoof::IfcRoof(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoof)) throw; entity = e; } +// IfcRoot +IfcGloballyUniqueId IfcRoot::GlobalId() { return *entity->getArgument(0); } +SHARED_PTR IfcRoot::OwnerHistory() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcRoot::hasName() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcRoot::Name() { return *entity->getArgument(2); } +bool IfcRoot::hasDescription() { return !entity->getArgument(3)->isNull(); } +IfcText IfcRoot::Description() { return *entity->getArgument(3); } +bool IfcRoot::is(Type::Enum v) { return v == Type::IfcRoot; } +Type::Enum IfcRoot::type() { return Type::IfcRoot; } +Type::Enum IfcRoot::Class() { return Type::IfcRoot; } +IfcRoot::IfcRoot(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoot)) throw; entity = e; } +// IfcRoundedEdgeFeature +bool IfcRoundedEdgeFeature::hasRadius() { return !entity->getArgument(9)->isNull(); } +IfcPositiveLengthMeasure IfcRoundedEdgeFeature::Radius() { return *entity->getArgument(9); } +bool IfcRoundedEdgeFeature::is(Type::Enum v) { return v == Type::IfcRoundedEdgeFeature || IfcEdgeFeature::is(v); } +Type::Enum IfcRoundedEdgeFeature::type() { return Type::IfcRoundedEdgeFeature; } +Type::Enum IfcRoundedEdgeFeature::Class() { return Type::IfcRoundedEdgeFeature; } +IfcRoundedEdgeFeature::IfcRoundedEdgeFeature(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoundedEdgeFeature)) throw; entity = e; } +// IfcRoundedRectangleProfileDef +IfcPositiveLengthMeasure IfcRoundedRectangleProfileDef::RoundingRadius() { return *entity->getArgument(5); } +bool IfcRoundedRectangleProfileDef::is(Type::Enum v) { return v == Type::IfcRoundedRectangleProfileDef || IfcRectangleProfileDef::is(v); } +Type::Enum IfcRoundedRectangleProfileDef::type() { return Type::IfcRoundedRectangleProfileDef; } +Type::Enum IfcRoundedRectangleProfileDef::Class() { return Type::IfcRoundedRectangleProfileDef; } +IfcRoundedRectangleProfileDef::IfcRoundedRectangleProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoundedRectangleProfileDef)) throw; entity = e; } +// IfcSIUnit +bool IfcSIUnit::hasPrefix() { return !entity->getArgument(2)->isNull(); } +IfcSIPrefix::IfcSIPrefix IfcSIUnit::Prefix() { return IfcSIPrefix::FromString(*entity->getArgument(2)); } +IfcSIUnitName::IfcSIUnitName IfcSIUnit::Name() { return IfcSIUnitName::FromString(*entity->getArgument(3)); } +bool IfcSIUnit::is(Type::Enum v) { return v == Type::IfcSIUnit || IfcNamedUnit::is(v); } +Type::Enum IfcSIUnit::type() { return Type::IfcSIUnit; } +Type::Enum IfcSIUnit::Class() { return Type::IfcSIUnit; } +IfcSIUnit::IfcSIUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcSIUnit)) throw; entity = e; } +// IfcSanitaryTerminalType +IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum IfcSanitaryTerminalType::PredefinedType() { return IfcSanitaryTerminalTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcSanitaryTerminalType::is(Type::Enum v) { return v == Type::IfcSanitaryTerminalType || IfcFlowTerminalType::is(v); } +Type::Enum IfcSanitaryTerminalType::type() { return Type::IfcSanitaryTerminalType; } +Type::Enum IfcSanitaryTerminalType::Class() { return Type::IfcSanitaryTerminalType; } +IfcSanitaryTerminalType::IfcSanitaryTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSanitaryTerminalType)) throw; entity = e; } +// IfcScheduleTimeControl +bool IfcScheduleTimeControl::hasActualStart() { return !entity->getArgument(5)->isNull(); } +IfcDateTimeSelect IfcScheduleTimeControl::ActualStart() { return *entity->getArgument(5); } +bool IfcScheduleTimeControl::hasEarlyStart() { return !entity->getArgument(6)->isNull(); } +IfcDateTimeSelect IfcScheduleTimeControl::EarlyStart() { return *entity->getArgument(6); } +bool IfcScheduleTimeControl::hasLateStart() { return !entity->getArgument(7)->isNull(); } +IfcDateTimeSelect IfcScheduleTimeControl::LateStart() { return *entity->getArgument(7); } +bool IfcScheduleTimeControl::hasScheduleStart() { return !entity->getArgument(8)->isNull(); } +IfcDateTimeSelect IfcScheduleTimeControl::ScheduleStart() { return *entity->getArgument(8); } +bool IfcScheduleTimeControl::hasActualFinish() { return !entity->getArgument(9)->isNull(); } +IfcDateTimeSelect IfcScheduleTimeControl::ActualFinish() { return *entity->getArgument(9); } +bool IfcScheduleTimeControl::hasEarlyFinish() { return !entity->getArgument(10)->isNull(); } +IfcDateTimeSelect IfcScheduleTimeControl::EarlyFinish() { return *entity->getArgument(10); } +bool IfcScheduleTimeControl::hasLateFinish() { return !entity->getArgument(11)->isNull(); } +IfcDateTimeSelect IfcScheduleTimeControl::LateFinish() { return *entity->getArgument(11); } +bool IfcScheduleTimeControl::hasScheduleFinish() { return !entity->getArgument(12)->isNull(); } +IfcDateTimeSelect IfcScheduleTimeControl::ScheduleFinish() { return *entity->getArgument(12); } +bool IfcScheduleTimeControl::hasScheduleDuration() { return !entity->getArgument(13)->isNull(); } +IfcTimeMeasure IfcScheduleTimeControl::ScheduleDuration() { return *entity->getArgument(13); } +bool IfcScheduleTimeControl::hasActualDuration() { return !entity->getArgument(14)->isNull(); } +IfcTimeMeasure IfcScheduleTimeControl::ActualDuration() { return *entity->getArgument(14); } +bool IfcScheduleTimeControl::hasRemainingTime() { return !entity->getArgument(15)->isNull(); } +IfcTimeMeasure IfcScheduleTimeControl::RemainingTime() { return *entity->getArgument(15); } +bool IfcScheduleTimeControl::hasFreeFloat() { return !entity->getArgument(16)->isNull(); } +IfcTimeMeasure IfcScheduleTimeControl::FreeFloat() { return *entity->getArgument(16); } +bool IfcScheduleTimeControl::hasTotalFloat() { return !entity->getArgument(17)->isNull(); } +IfcTimeMeasure IfcScheduleTimeControl::TotalFloat() { return *entity->getArgument(17); } +bool IfcScheduleTimeControl::hasIsCritical() { return !entity->getArgument(18)->isNull(); } +bool IfcScheduleTimeControl::IsCritical() { return *entity->getArgument(18); } +bool IfcScheduleTimeControl::hasStatusTime() { return !entity->getArgument(19)->isNull(); } +IfcDateTimeSelect IfcScheduleTimeControl::StatusTime() { return *entity->getArgument(19); } +bool IfcScheduleTimeControl::hasStartFloat() { return !entity->getArgument(20)->isNull(); } +IfcTimeMeasure IfcScheduleTimeControl::StartFloat() { return *entity->getArgument(20); } +bool IfcScheduleTimeControl::hasFinishFloat() { return !entity->getArgument(21)->isNull(); } +IfcTimeMeasure IfcScheduleTimeControl::FinishFloat() { return *entity->getArgument(21); } +bool IfcScheduleTimeControl::hasCompletion() { return !entity->getArgument(22)->isNull(); } +IfcPositiveRatioMeasure IfcScheduleTimeControl::Completion() { return *entity->getArgument(22); } +IfcRelAssignsTasks::list IfcScheduleTimeControl::ScheduleTimeControlAssigned() { RETURN_INVERSE(IfcRelAssignsTasks) } +bool IfcScheduleTimeControl::is(Type::Enum v) { return v == Type::IfcScheduleTimeControl || IfcControl::is(v); } +Type::Enum IfcScheduleTimeControl::type() { return Type::IfcScheduleTimeControl; } +Type::Enum IfcScheduleTimeControl::Class() { return Type::IfcScheduleTimeControl; } +IfcScheduleTimeControl::IfcScheduleTimeControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcScheduleTimeControl)) throw; entity = e; } +// IfcSectionProperties +IfcSectionTypeEnum::IfcSectionTypeEnum IfcSectionProperties::SectionType() { return IfcSectionTypeEnum::FromString(*entity->getArgument(0)); } +SHARED_PTR IfcSectionProperties::StartProfile() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcSectionProperties::hasEndProfile() { return !entity->getArgument(2)->isNull(); } +SHARED_PTR IfcSectionProperties::EndProfile() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcSectionProperties::is(Type::Enum v) { return v == Type::IfcSectionProperties; } +Type::Enum IfcSectionProperties::type() { return Type::IfcSectionProperties; } +Type::Enum IfcSectionProperties::Class() { return Type::IfcSectionProperties; } +IfcSectionProperties::IfcSectionProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSectionProperties)) throw; entity = e; } +// IfcSectionReinforcementProperties +IfcLengthMeasure IfcSectionReinforcementProperties::LongitudinalStartPosition() { return *entity->getArgument(0); } +IfcLengthMeasure IfcSectionReinforcementProperties::LongitudinalEndPosition() { return *entity->getArgument(1); } +bool IfcSectionReinforcementProperties::hasTransversePosition() { return !entity->getArgument(2)->isNull(); } +IfcLengthMeasure IfcSectionReinforcementProperties::TransversePosition() { return *entity->getArgument(2); } +IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum IfcSectionReinforcementProperties::ReinforcementRole() { return IfcReinforcingBarRoleEnum::FromString(*entity->getArgument(3)); } +SHARED_PTR IfcSectionReinforcementProperties::SectionDefinition() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +SHARED_PTR< IfcTemplatedEntityList > IfcSectionReinforcementProperties::CrossSectionReinforcementDefinitions() { RETURN_AS_LIST(IfcReinforcementBarProperties,5) } +bool IfcSectionReinforcementProperties::is(Type::Enum v) { return v == Type::IfcSectionReinforcementProperties; } +Type::Enum IfcSectionReinforcementProperties::type() { return Type::IfcSectionReinforcementProperties; } +Type::Enum IfcSectionReinforcementProperties::Class() { return Type::IfcSectionReinforcementProperties; } +IfcSectionReinforcementProperties::IfcSectionReinforcementProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSectionReinforcementProperties)) throw; entity = e; } +// IfcSectionedSpine +SHARED_PTR IfcSectionedSpine::SpineCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR< IfcTemplatedEntityList > IfcSectionedSpine::CrossSections() { RETURN_AS_LIST(IfcProfileDef,1) } +SHARED_PTR< IfcTemplatedEntityList > IfcSectionedSpine::CrossSectionPositions() { RETURN_AS_LIST(IfcAxis2Placement3D,2) } +bool IfcSectionedSpine::is(Type::Enum v) { return v == Type::IfcSectionedSpine || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcSectionedSpine::type() { return Type::IfcSectionedSpine; } +Type::Enum IfcSectionedSpine::Class() { return Type::IfcSectionedSpine; } +IfcSectionedSpine::IfcSectionedSpine(IfcAbstractEntityPtr e) { if (!is(Type::IfcSectionedSpine)) throw; entity = e; } +// IfcSensorType +IfcSensorTypeEnum::IfcSensorTypeEnum IfcSensorType::PredefinedType() { return IfcSensorTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcSensorType::is(Type::Enum v) { return v == Type::IfcSensorType || IfcDistributionControlElementType::is(v); } +Type::Enum IfcSensorType::type() { return Type::IfcSensorType; } +Type::Enum IfcSensorType::Class() { return Type::IfcSensorType; } +IfcSensorType::IfcSensorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSensorType)) throw; entity = e; } +// IfcServiceLife +IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum IfcServiceLife::ServiceLifeType() { return IfcServiceLifeTypeEnum::FromString(*entity->getArgument(5)); } +IfcTimeMeasure IfcServiceLife::ServiceLifeDuration() { return *entity->getArgument(6); } +bool IfcServiceLife::is(Type::Enum v) { return v == Type::IfcServiceLife || IfcControl::is(v); } +Type::Enum IfcServiceLife::type() { return Type::IfcServiceLife; } +Type::Enum IfcServiceLife::Class() { return Type::IfcServiceLife; } +IfcServiceLife::IfcServiceLife(IfcAbstractEntityPtr e) { if (!is(Type::IfcServiceLife)) throw; entity = e; } +// IfcServiceLifeFactor +IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum IfcServiceLifeFactor::PredefinedType() { return IfcServiceLifeFactorTypeEnum::FromString(*entity->getArgument(4)); } +bool IfcServiceLifeFactor::hasUpperValue() { return !entity->getArgument(5)->isNull(); } +IfcMeasureValue IfcServiceLifeFactor::UpperValue() { return *entity->getArgument(5); } +IfcMeasureValue IfcServiceLifeFactor::MostUsedValue() { return *entity->getArgument(6); } +bool IfcServiceLifeFactor::hasLowerValue() { return !entity->getArgument(7)->isNull(); } +IfcMeasureValue IfcServiceLifeFactor::LowerValue() { return *entity->getArgument(7); } +bool IfcServiceLifeFactor::is(Type::Enum v) { return v == Type::IfcServiceLifeFactor || IfcPropertySetDefinition::is(v); } +Type::Enum IfcServiceLifeFactor::type() { return Type::IfcServiceLifeFactor; } +Type::Enum IfcServiceLifeFactor::Class() { return Type::IfcServiceLifeFactor; } +IfcServiceLifeFactor::IfcServiceLifeFactor(IfcAbstractEntityPtr e) { if (!is(Type::IfcServiceLifeFactor)) throw; entity = e; } +// IfcShapeAspect +SHARED_PTR< IfcTemplatedEntityList > IfcShapeAspect::ShapeRepresentations() { RETURN_AS_LIST(IfcShapeModel,0) } +bool IfcShapeAspect::hasName() { return !entity->getArgument(1)->isNull(); } +IfcLabel IfcShapeAspect::Name() { return *entity->getArgument(1); } +bool IfcShapeAspect::hasDescription() { return !entity->getArgument(2)->isNull(); } +IfcText IfcShapeAspect::Description() { return *entity->getArgument(2); } +bool IfcShapeAspect::ProductDefinitional() { return *entity->getArgument(3); } +SHARED_PTR IfcShapeAspect::PartOfProductDefinitionShape() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +bool IfcShapeAspect::is(Type::Enum v) { return v == Type::IfcShapeAspect; } +Type::Enum IfcShapeAspect::type() { return Type::IfcShapeAspect; } +Type::Enum IfcShapeAspect::Class() { return Type::IfcShapeAspect; } +IfcShapeAspect::IfcShapeAspect(IfcAbstractEntityPtr e) { if (!is(Type::IfcShapeAspect)) throw; entity = e; } +// IfcShapeModel +IfcShapeAspect::list IfcShapeModel::OfShapeAspect() { RETURN_INVERSE(IfcShapeAspect) } +bool IfcShapeModel::is(Type::Enum v) { return v == Type::IfcShapeModel || IfcRepresentation::is(v); } +Type::Enum IfcShapeModel::type() { return Type::IfcShapeModel; } +Type::Enum IfcShapeModel::Class() { return Type::IfcShapeModel; } +IfcShapeModel::IfcShapeModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcShapeModel)) throw; entity = e; } +// IfcShapeRepresentation +bool IfcShapeRepresentation::is(Type::Enum v) { return v == Type::IfcShapeRepresentation || IfcShapeModel::is(v); } +Type::Enum IfcShapeRepresentation::type() { return Type::IfcShapeRepresentation; } +Type::Enum IfcShapeRepresentation::Class() { return Type::IfcShapeRepresentation; } +IfcShapeRepresentation::IfcShapeRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcShapeRepresentation)) throw; entity = e; } +// IfcShellBasedSurfaceModel +SHARED_PTR< IfcTemplatedEntityList > IfcShellBasedSurfaceModel::SbsmBoundary() { RETURN_AS_LIST(IfcAbstractSelect,0) } +bool IfcShellBasedSurfaceModel::is(Type::Enum v) { return v == Type::IfcShellBasedSurfaceModel || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcShellBasedSurfaceModel::type() { return Type::IfcShellBasedSurfaceModel; } +Type::Enum IfcShellBasedSurfaceModel::Class() { return Type::IfcShellBasedSurfaceModel; } +IfcShellBasedSurfaceModel::IfcShellBasedSurfaceModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcShellBasedSurfaceModel)) throw; entity = e; } +// IfcSimpleProperty +bool IfcSimpleProperty::is(Type::Enum v) { return v == Type::IfcSimpleProperty || IfcProperty::is(v); } +Type::Enum IfcSimpleProperty::type() { return Type::IfcSimpleProperty; } +Type::Enum IfcSimpleProperty::Class() { return Type::IfcSimpleProperty; } +IfcSimpleProperty::IfcSimpleProperty(IfcAbstractEntityPtr e) { if (!is(Type::IfcSimpleProperty)) throw; entity = e; } +// IfcSite +bool IfcSite::hasRefLatitude() { return !entity->getArgument(9)->isNull(); } +IfcCompoundPlaneAngleMeasure IfcSite::RefLatitude() { return *entity->getArgument(9); } +bool IfcSite::hasRefLongitude() { return !entity->getArgument(10)->isNull(); } +IfcCompoundPlaneAngleMeasure IfcSite::RefLongitude() { return *entity->getArgument(10); } +bool IfcSite::hasRefElevation() { return !entity->getArgument(11)->isNull(); } +IfcLengthMeasure IfcSite::RefElevation() { return *entity->getArgument(11); } +bool IfcSite::hasLandTitleNumber() { return !entity->getArgument(12)->isNull(); } +IfcLabel IfcSite::LandTitleNumber() { return *entity->getArgument(12); } +bool IfcSite::hasSiteAddress() { return !entity->getArgument(13)->isNull(); } +SHARED_PTR IfcSite::SiteAddress() { return reinterpret_pointer_cast(*entity->getArgument(13)); } +bool IfcSite::is(Type::Enum v) { return v == Type::IfcSite || IfcSpatialStructureElement::is(v); } +Type::Enum IfcSite::type() { return Type::IfcSite; } +Type::Enum IfcSite::Class() { return Type::IfcSite; } +IfcSite::IfcSite(IfcAbstractEntityPtr e) { if (!is(Type::IfcSite)) throw; entity = e; } +// IfcSlab +bool IfcSlab::hasPredefinedType() { return !entity->getArgument(8)->isNull(); } +IfcSlabTypeEnum::IfcSlabTypeEnum IfcSlab::PredefinedType() { return IfcSlabTypeEnum::FromString(*entity->getArgument(8)); } +bool IfcSlab::is(Type::Enum v) { return v == Type::IfcSlab || IfcBuildingElement::is(v); } +Type::Enum IfcSlab::type() { return Type::IfcSlab; } +Type::Enum IfcSlab::Class() { return Type::IfcSlab; } +IfcSlab::IfcSlab(IfcAbstractEntityPtr e) { if (!is(Type::IfcSlab)) throw; entity = e; } +// IfcSlabType +IfcSlabTypeEnum::IfcSlabTypeEnum IfcSlabType::PredefinedType() { return IfcSlabTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcSlabType::is(Type::Enum v) { return v == Type::IfcSlabType || IfcBuildingElementType::is(v); } +Type::Enum IfcSlabType::type() { return Type::IfcSlabType; } +Type::Enum IfcSlabType::Class() { return Type::IfcSlabType; } +IfcSlabType::IfcSlabType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSlabType)) throw; entity = e; } +// IfcSlippageConnectionCondition +bool IfcSlippageConnectionCondition::hasSlippageX() { return !entity->getArgument(1)->isNull(); } +IfcLengthMeasure IfcSlippageConnectionCondition::SlippageX() { return *entity->getArgument(1); } +bool IfcSlippageConnectionCondition::hasSlippageY() { return !entity->getArgument(2)->isNull(); } +IfcLengthMeasure IfcSlippageConnectionCondition::SlippageY() { return *entity->getArgument(2); } +bool IfcSlippageConnectionCondition::hasSlippageZ() { return !entity->getArgument(3)->isNull(); } +IfcLengthMeasure IfcSlippageConnectionCondition::SlippageZ() { return *entity->getArgument(3); } +bool IfcSlippageConnectionCondition::is(Type::Enum v) { return v == Type::IfcSlippageConnectionCondition || IfcStructuralConnectionCondition::is(v); } +Type::Enum IfcSlippageConnectionCondition::type() { return Type::IfcSlippageConnectionCondition; } +Type::Enum IfcSlippageConnectionCondition::Class() { return Type::IfcSlippageConnectionCondition; } +IfcSlippageConnectionCondition::IfcSlippageConnectionCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcSlippageConnectionCondition)) throw; entity = e; } +// IfcSolidModel +bool IfcSolidModel::is(Type::Enum v) { return v == Type::IfcSolidModel || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcSolidModel::type() { return Type::IfcSolidModel; } +Type::Enum IfcSolidModel::Class() { return Type::IfcSolidModel; } +IfcSolidModel::IfcSolidModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcSolidModel)) throw; entity = e; } +// IfcSoundProperties +IfcBoolean IfcSoundProperties::IsAttenuating() { return *entity->getArgument(4); } +bool IfcSoundProperties::hasSoundScale() { return !entity->getArgument(5)->isNull(); } +IfcSoundScaleEnum::IfcSoundScaleEnum IfcSoundProperties::SoundScale() { return IfcSoundScaleEnum::FromString(*entity->getArgument(5)); } +SHARED_PTR< IfcTemplatedEntityList > IfcSoundProperties::SoundValues() { RETURN_AS_LIST(IfcSoundValue,6) } +bool IfcSoundProperties::is(Type::Enum v) { return v == Type::IfcSoundProperties || IfcPropertySetDefinition::is(v); } +Type::Enum IfcSoundProperties::type() { return Type::IfcSoundProperties; } +Type::Enum IfcSoundProperties::Class() { return Type::IfcSoundProperties; } +IfcSoundProperties::IfcSoundProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSoundProperties)) throw; entity = e; } +// IfcSoundValue +bool IfcSoundValue::hasSoundLevelTimeSeries() { return !entity->getArgument(4)->isNull(); } +SHARED_PTR IfcSoundValue::SoundLevelTimeSeries() { return reinterpret_pointer_cast(*entity->getArgument(4)); } +IfcFrequencyMeasure IfcSoundValue::Frequency() { return *entity->getArgument(5); } +bool IfcSoundValue::hasSoundLevelSingleValue() { return !entity->getArgument(6)->isNull(); } +IfcDerivedMeasureValue IfcSoundValue::SoundLevelSingleValue() { return *entity->getArgument(6); } +bool IfcSoundValue::is(Type::Enum v) { return v == Type::IfcSoundValue || IfcPropertySetDefinition::is(v); } +Type::Enum IfcSoundValue::type() { return Type::IfcSoundValue; } +Type::Enum IfcSoundValue::Class() { return Type::IfcSoundValue; } +IfcSoundValue::IfcSoundValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcSoundValue)) throw; entity = e; } +// IfcSpace +IfcInternalOrExternalEnum::IfcInternalOrExternalEnum IfcSpace::InteriorOrExteriorSpace() { return IfcInternalOrExternalEnum::FromString(*entity->getArgument(9)); } +bool IfcSpace::hasElevationWithFlooring() { return !entity->getArgument(10)->isNull(); } +IfcLengthMeasure IfcSpace::ElevationWithFlooring() { return *entity->getArgument(10); } +IfcRelCoversSpaces::list IfcSpace::HasCoverings() { RETURN_INVERSE(IfcRelCoversSpaces) } +IfcRelSpaceBoundary::list IfcSpace::BoundedBy() { RETURN_INVERSE(IfcRelSpaceBoundary) } +bool IfcSpace::is(Type::Enum v) { return v == Type::IfcSpace || IfcSpatialStructureElement::is(v); } +Type::Enum IfcSpace::type() { return Type::IfcSpace; } +Type::Enum IfcSpace::Class() { return Type::IfcSpace; } +IfcSpace::IfcSpace(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpace)) throw; entity = e; } +// IfcSpaceHeaterType +IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum IfcSpaceHeaterType::PredefinedType() { return IfcSpaceHeaterTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcSpaceHeaterType::is(Type::Enum v) { return v == Type::IfcSpaceHeaterType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcSpaceHeaterType::type() { return Type::IfcSpaceHeaterType; } +Type::Enum IfcSpaceHeaterType::Class() { return Type::IfcSpaceHeaterType; } +IfcSpaceHeaterType::IfcSpaceHeaterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceHeaterType)) throw; entity = e; } +// IfcSpaceProgram +IfcIdentifier IfcSpaceProgram::SpaceProgramIdentifier() { return *entity->getArgument(5); } +bool IfcSpaceProgram::hasMaxRequiredArea() { return !entity->getArgument(6)->isNull(); } +IfcAreaMeasure IfcSpaceProgram::MaxRequiredArea() { return *entity->getArgument(6); } +bool IfcSpaceProgram::hasMinRequiredArea() { return !entity->getArgument(7)->isNull(); } +IfcAreaMeasure IfcSpaceProgram::MinRequiredArea() { return *entity->getArgument(7); } +bool IfcSpaceProgram::hasRequestedLocation() { return !entity->getArgument(8)->isNull(); } +SHARED_PTR IfcSpaceProgram::RequestedLocation() { return reinterpret_pointer_cast(*entity->getArgument(8)); } +IfcAreaMeasure IfcSpaceProgram::StandardRequiredArea() { return *entity->getArgument(9); } +IfcRelInteractionRequirements::list IfcSpaceProgram::HasInteractionReqsFrom() { RETURN_INVERSE(IfcRelInteractionRequirements) } +IfcRelInteractionRequirements::list IfcSpaceProgram::HasInteractionReqsTo() { RETURN_INVERSE(IfcRelInteractionRequirements) } +bool IfcSpaceProgram::is(Type::Enum v) { return v == Type::IfcSpaceProgram || IfcControl::is(v); } +Type::Enum IfcSpaceProgram::type() { return Type::IfcSpaceProgram; } +Type::Enum IfcSpaceProgram::Class() { return Type::IfcSpaceProgram; } +IfcSpaceProgram::IfcSpaceProgram(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceProgram)) throw; entity = e; } +// IfcSpaceThermalLoadProperties +bool IfcSpaceThermalLoadProperties::hasApplicableValueRatio() { return !entity->getArgument(4)->isNull(); } +IfcPositiveRatioMeasure IfcSpaceThermalLoadProperties::ApplicableValueRatio() { return *entity->getArgument(4); } +IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum IfcSpaceThermalLoadProperties::ThermalLoadSource() { return IfcThermalLoadSourceEnum::FromString(*entity->getArgument(5)); } +IfcPropertySourceEnum::IfcPropertySourceEnum IfcSpaceThermalLoadProperties::PropertySource() { return IfcPropertySourceEnum::FromString(*entity->getArgument(6)); } +bool IfcSpaceThermalLoadProperties::hasSourceDescription() { return !entity->getArgument(7)->isNull(); } +IfcText IfcSpaceThermalLoadProperties::SourceDescription() { return *entity->getArgument(7); } +IfcPowerMeasure IfcSpaceThermalLoadProperties::MaximumValue() { return *entity->getArgument(8); } +bool IfcSpaceThermalLoadProperties::hasMinimumValue() { return !entity->getArgument(9)->isNull(); } +IfcPowerMeasure IfcSpaceThermalLoadProperties::MinimumValue() { return *entity->getArgument(9); } +bool IfcSpaceThermalLoadProperties::hasThermalLoadTimeSeriesValues() { return !entity->getArgument(10)->isNull(); } +SHARED_PTR IfcSpaceThermalLoadProperties::ThermalLoadTimeSeriesValues() { return reinterpret_pointer_cast(*entity->getArgument(10)); } +bool IfcSpaceThermalLoadProperties::hasUserDefinedThermalLoadSource() { return !entity->getArgument(11)->isNull(); } +IfcLabel IfcSpaceThermalLoadProperties::UserDefinedThermalLoadSource() { return *entity->getArgument(11); } +bool IfcSpaceThermalLoadProperties::hasUserDefinedPropertySource() { return !entity->getArgument(12)->isNull(); } +IfcLabel IfcSpaceThermalLoadProperties::UserDefinedPropertySource() { return *entity->getArgument(12); } +IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum IfcSpaceThermalLoadProperties::ThermalLoadType() { return IfcThermalLoadTypeEnum::FromString(*entity->getArgument(13)); } +bool IfcSpaceThermalLoadProperties::is(Type::Enum v) { return v == Type::IfcSpaceThermalLoadProperties || IfcPropertySetDefinition::is(v); } +Type::Enum IfcSpaceThermalLoadProperties::type() { return Type::IfcSpaceThermalLoadProperties; } +Type::Enum IfcSpaceThermalLoadProperties::Class() { return Type::IfcSpaceThermalLoadProperties; } +IfcSpaceThermalLoadProperties::IfcSpaceThermalLoadProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceThermalLoadProperties)) throw; entity = e; } +// IfcSpaceType +IfcSpaceTypeEnum::IfcSpaceTypeEnum IfcSpaceType::PredefinedType() { return IfcSpaceTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcSpaceType::is(Type::Enum v) { return v == Type::IfcSpaceType || IfcSpatialStructureElementType::is(v); } +Type::Enum IfcSpaceType::type() { return Type::IfcSpaceType; } +Type::Enum IfcSpaceType::Class() { return Type::IfcSpaceType; } +IfcSpaceType::IfcSpaceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceType)) throw; entity = e; } +// IfcSpatialStructureElement +bool IfcSpatialStructureElement::hasLongName() { return !entity->getArgument(7)->isNull(); } +IfcLabel IfcSpatialStructureElement::LongName() { return *entity->getArgument(7); } +IfcElementCompositionEnum::IfcElementCompositionEnum IfcSpatialStructureElement::CompositionType() { return IfcElementCompositionEnum::FromString(*entity->getArgument(8)); } +IfcRelReferencedInSpatialStructure::list IfcSpatialStructureElement::ReferencesElements() { RETURN_INVERSE(IfcRelReferencedInSpatialStructure) } +IfcRelServicesBuildings::list IfcSpatialStructureElement::ServicedBySystems() { RETURN_INVERSE(IfcRelServicesBuildings) } +IfcRelContainedInSpatialStructure::list IfcSpatialStructureElement::ContainsElements() { RETURN_INVERSE(IfcRelContainedInSpatialStructure) } +bool IfcSpatialStructureElement::is(Type::Enum v) { return v == Type::IfcSpatialStructureElement || IfcProduct::is(v); } +Type::Enum IfcSpatialStructureElement::type() { return Type::IfcSpatialStructureElement; } +Type::Enum IfcSpatialStructureElement::Class() { return Type::IfcSpatialStructureElement; } +IfcSpatialStructureElement::IfcSpatialStructureElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpatialStructureElement)) throw; entity = e; } +// IfcSpatialStructureElementType +bool IfcSpatialStructureElementType::is(Type::Enum v) { return v == Type::IfcSpatialStructureElementType || IfcElementType::is(v); } +Type::Enum IfcSpatialStructureElementType::type() { return Type::IfcSpatialStructureElementType; } +Type::Enum IfcSpatialStructureElementType::Class() { return Type::IfcSpatialStructureElementType; } +IfcSpatialStructureElementType::IfcSpatialStructureElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpatialStructureElementType)) throw; entity = e; } +// IfcSphere +IfcPositiveLengthMeasure IfcSphere::Radius() { return *entity->getArgument(1); } +bool IfcSphere::is(Type::Enum v) { return v == Type::IfcSphere || IfcCsgPrimitive3D::is(v); } +Type::Enum IfcSphere::type() { return Type::IfcSphere; } +Type::Enum IfcSphere::Class() { return Type::IfcSphere; } +IfcSphere::IfcSphere(IfcAbstractEntityPtr e) { if (!is(Type::IfcSphere)) throw; entity = e; } +// IfcStackTerminalType +IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum IfcStackTerminalType::PredefinedType() { return IfcStackTerminalTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcStackTerminalType::is(Type::Enum v) { return v == Type::IfcStackTerminalType || IfcFlowTerminalType::is(v); } +Type::Enum IfcStackTerminalType::type() { return Type::IfcStackTerminalType; } +Type::Enum IfcStackTerminalType::Class() { return Type::IfcStackTerminalType; } +IfcStackTerminalType::IfcStackTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcStackTerminalType)) throw; entity = e; } +// IfcStair +IfcStairTypeEnum::IfcStairTypeEnum IfcStair::ShapeType() { return IfcStairTypeEnum::FromString(*entity->getArgument(8)); } +bool IfcStair::is(Type::Enum v) { return v == Type::IfcStair || IfcBuildingElement::is(v); } +Type::Enum IfcStair::type() { return Type::IfcStair; } +Type::Enum IfcStair::Class() { return Type::IfcStair; } +IfcStair::IfcStair(IfcAbstractEntityPtr e) { if (!is(Type::IfcStair)) throw; entity = e; } +// IfcStairFlight +bool IfcStairFlight::hasNumberOfRiser() { return !entity->getArgument(8)->isNull(); } +int IfcStairFlight::NumberOfRiser() { return *entity->getArgument(8); } +bool IfcStairFlight::hasNumberOfTreads() { return !entity->getArgument(9)->isNull(); } +int IfcStairFlight::NumberOfTreads() { return *entity->getArgument(9); } +bool IfcStairFlight::hasRiserHeight() { return !entity->getArgument(10)->isNull(); } +IfcPositiveLengthMeasure IfcStairFlight::RiserHeight() { return *entity->getArgument(10); } +bool IfcStairFlight::hasTreadLength() { return !entity->getArgument(11)->isNull(); } +IfcPositiveLengthMeasure IfcStairFlight::TreadLength() { return *entity->getArgument(11); } +bool IfcStairFlight::is(Type::Enum v) { return v == Type::IfcStairFlight || IfcBuildingElement::is(v); } +Type::Enum IfcStairFlight::type() { return Type::IfcStairFlight; } +Type::Enum IfcStairFlight::Class() { return Type::IfcStairFlight; } +IfcStairFlight::IfcStairFlight(IfcAbstractEntityPtr e) { if (!is(Type::IfcStairFlight)) throw; entity = e; } +// IfcStairFlightType +IfcStairFlightTypeEnum::IfcStairFlightTypeEnum IfcStairFlightType::PredefinedType() { return IfcStairFlightTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcStairFlightType::is(Type::Enum v) { return v == Type::IfcStairFlightType || IfcBuildingElementType::is(v); } +Type::Enum IfcStairFlightType::type() { return Type::IfcStairFlightType; } +Type::Enum IfcStairFlightType::Class() { return Type::IfcStairFlightType; } +IfcStairFlightType::IfcStairFlightType(IfcAbstractEntityPtr e) { if (!is(Type::IfcStairFlightType)) throw; entity = e; } +// IfcStructuralAction +bool IfcStructuralAction::DestabilizingLoad() { return *entity->getArgument(9); } +bool IfcStructuralAction::hasCausedBy() { return !entity->getArgument(10)->isNull(); } +SHARED_PTR IfcStructuralAction::CausedBy() { return reinterpret_pointer_cast(*entity->getArgument(10)); } +bool IfcStructuralAction::is(Type::Enum v) { return v == Type::IfcStructuralAction || IfcStructuralActivity::is(v); } +Type::Enum IfcStructuralAction::type() { return Type::IfcStructuralAction; } +Type::Enum IfcStructuralAction::Class() { return Type::IfcStructuralAction; } +IfcStructuralAction::IfcStructuralAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralAction)) throw; entity = e; } +// IfcStructuralActivity +SHARED_PTR IfcStructuralActivity::AppliedLoad() { return reinterpret_pointer_cast(*entity->getArgument(7)); } +IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum IfcStructuralActivity::GlobalOrLocal() { return IfcGlobalOrLocalEnum::FromString(*entity->getArgument(8)); } +IfcRelConnectsStructuralActivity::list IfcStructuralActivity::AssignedToStructuralItem() { RETURN_INVERSE(IfcRelConnectsStructuralActivity) } +bool IfcStructuralActivity::is(Type::Enum v) { return v == Type::IfcStructuralActivity || IfcProduct::is(v); } +Type::Enum IfcStructuralActivity::type() { return Type::IfcStructuralActivity; } +Type::Enum IfcStructuralActivity::Class() { return Type::IfcStructuralActivity; } +IfcStructuralActivity::IfcStructuralActivity(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralActivity)) throw; entity = e; } +// IfcStructuralAnalysisModel +IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum IfcStructuralAnalysisModel::PredefinedType() { return IfcAnalysisModelTypeEnum::FromString(*entity->getArgument(5)); } +bool IfcStructuralAnalysisModel::hasOrientationOf2DPlane() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR IfcStructuralAnalysisModel::OrientationOf2DPlane() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcStructuralAnalysisModel::hasLoadedBy() { return !entity->getArgument(7)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcStructuralAnalysisModel::LoadedBy() { RETURN_AS_LIST(IfcStructuralLoadGroup,7) } +bool IfcStructuralAnalysisModel::hasHasResults() { return !entity->getArgument(8)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcStructuralAnalysisModel::HasResults() { RETURN_AS_LIST(IfcStructuralResultGroup,8) } +bool IfcStructuralAnalysisModel::is(Type::Enum v) { return v == Type::IfcStructuralAnalysisModel || IfcSystem::is(v); } +Type::Enum IfcStructuralAnalysisModel::type() { return Type::IfcStructuralAnalysisModel; } +Type::Enum IfcStructuralAnalysisModel::Class() { return Type::IfcStructuralAnalysisModel; } +IfcStructuralAnalysisModel::IfcStructuralAnalysisModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralAnalysisModel)) throw; entity = e; } +// IfcStructuralConnection +bool IfcStructuralConnection::hasAppliedCondition() { return !entity->getArgument(7)->isNull(); } +SHARED_PTR IfcStructuralConnection::AppliedCondition() { return reinterpret_pointer_cast(*entity->getArgument(7)); } +IfcRelConnectsStructuralMember::list IfcStructuralConnection::ConnectsStructuralMembers() { RETURN_INVERSE(IfcRelConnectsStructuralMember) } +bool IfcStructuralConnection::is(Type::Enum v) { return v == Type::IfcStructuralConnection || IfcStructuralItem::is(v); } +Type::Enum IfcStructuralConnection::type() { return Type::IfcStructuralConnection; } +Type::Enum IfcStructuralConnection::Class() { return Type::IfcStructuralConnection; } +IfcStructuralConnection::IfcStructuralConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralConnection)) throw; entity = e; } +// IfcStructuralConnectionCondition +bool IfcStructuralConnectionCondition::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcStructuralConnectionCondition::Name() { return *entity->getArgument(0); } +bool IfcStructuralConnectionCondition::is(Type::Enum v) { return v == Type::IfcStructuralConnectionCondition; } +Type::Enum IfcStructuralConnectionCondition::type() { return Type::IfcStructuralConnectionCondition; } +Type::Enum IfcStructuralConnectionCondition::Class() { return Type::IfcStructuralConnectionCondition; } +IfcStructuralConnectionCondition::IfcStructuralConnectionCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralConnectionCondition)) throw; entity = e; } +// IfcStructuralCurveConnection +bool IfcStructuralCurveConnection::is(Type::Enum v) { return v == Type::IfcStructuralCurveConnection || IfcStructuralConnection::is(v); } +Type::Enum IfcStructuralCurveConnection::type() { return Type::IfcStructuralCurveConnection; } +Type::Enum IfcStructuralCurveConnection::Class() { return Type::IfcStructuralCurveConnection; } +IfcStructuralCurveConnection::IfcStructuralCurveConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralCurveConnection)) throw; entity = e; } +// IfcStructuralCurveMember +IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum IfcStructuralCurveMember::PredefinedType() { return IfcStructuralCurveTypeEnum::FromString(*entity->getArgument(7)); } +bool IfcStructuralCurveMember::is(Type::Enum v) { return v == Type::IfcStructuralCurveMember || IfcStructuralMember::is(v); } +Type::Enum IfcStructuralCurveMember::type() { return Type::IfcStructuralCurveMember; } +Type::Enum IfcStructuralCurveMember::Class() { return Type::IfcStructuralCurveMember; } +IfcStructuralCurveMember::IfcStructuralCurveMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralCurveMember)) throw; entity = e; } +// IfcStructuralCurveMemberVarying +bool IfcStructuralCurveMemberVarying::is(Type::Enum v) { return v == Type::IfcStructuralCurveMemberVarying || IfcStructuralCurveMember::is(v); } +Type::Enum IfcStructuralCurveMemberVarying::type() { return Type::IfcStructuralCurveMemberVarying; } +Type::Enum IfcStructuralCurveMemberVarying::Class() { return Type::IfcStructuralCurveMemberVarying; } +IfcStructuralCurveMemberVarying::IfcStructuralCurveMemberVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralCurveMemberVarying)) throw; entity = e; } +// IfcStructuralItem +IfcRelConnectsStructuralActivity::list IfcStructuralItem::AssignedStructuralActivity() { RETURN_INVERSE(IfcRelConnectsStructuralActivity) } +bool IfcStructuralItem::is(Type::Enum v) { return v == Type::IfcStructuralItem || IfcProduct::is(v); } +Type::Enum IfcStructuralItem::type() { return Type::IfcStructuralItem; } +Type::Enum IfcStructuralItem::Class() { return Type::IfcStructuralItem; } +IfcStructuralItem::IfcStructuralItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralItem)) throw; entity = e; } +// IfcStructuralLinearAction +IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralLinearAction::ProjectedOrTrue() { return IfcProjectedOrTrueLengthEnum::FromString(*entity->getArgument(11)); } +bool IfcStructuralLinearAction::is(Type::Enum v) { return v == Type::IfcStructuralLinearAction || IfcStructuralAction::is(v); } +Type::Enum IfcStructuralLinearAction::type() { return Type::IfcStructuralLinearAction; } +Type::Enum IfcStructuralLinearAction::Class() { return Type::IfcStructuralLinearAction; } +IfcStructuralLinearAction::IfcStructuralLinearAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLinearAction)) throw; entity = e; } +// IfcStructuralLinearActionVarying +SHARED_PTR IfcStructuralLinearActionVarying::VaryingAppliedLoadLocation() { return reinterpret_pointer_cast(*entity->getArgument(12)); } +SHARED_PTR< IfcTemplatedEntityList > IfcStructuralLinearActionVarying::SubsequentAppliedLoads() { RETURN_AS_LIST(IfcStructuralLoad,13) } +bool IfcStructuralLinearActionVarying::is(Type::Enum v) { return v == Type::IfcStructuralLinearActionVarying || IfcStructuralLinearAction::is(v); } +Type::Enum IfcStructuralLinearActionVarying::type() { return Type::IfcStructuralLinearActionVarying; } +Type::Enum IfcStructuralLinearActionVarying::Class() { return Type::IfcStructuralLinearActionVarying; } +IfcStructuralLinearActionVarying::IfcStructuralLinearActionVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLinearActionVarying)) throw; entity = e; } +// IfcStructuralLoad +bool IfcStructuralLoad::hasName() { return !entity->getArgument(0)->isNull(); } +IfcLabel IfcStructuralLoad::Name() { return *entity->getArgument(0); } +bool IfcStructuralLoad::is(Type::Enum v) { return v == Type::IfcStructuralLoad; } +Type::Enum IfcStructuralLoad::type() { return Type::IfcStructuralLoad; } +Type::Enum IfcStructuralLoad::Class() { return Type::IfcStructuralLoad; } +IfcStructuralLoad::IfcStructuralLoad(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoad)) throw; entity = e; } +// IfcStructuralLoadGroup +IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum IfcStructuralLoadGroup::PredefinedType() { return IfcLoadGroupTypeEnum::FromString(*entity->getArgument(5)); } +IfcActionTypeEnum::IfcActionTypeEnum IfcStructuralLoadGroup::ActionType() { return IfcActionTypeEnum::FromString(*entity->getArgument(6)); } +IfcActionSourceTypeEnum::IfcActionSourceTypeEnum IfcStructuralLoadGroup::ActionSource() { return IfcActionSourceTypeEnum::FromString(*entity->getArgument(7)); } +bool IfcStructuralLoadGroup::hasCoefficient() { return !entity->getArgument(8)->isNull(); } +IfcRatioMeasure IfcStructuralLoadGroup::Coefficient() { return *entity->getArgument(8); } +bool IfcStructuralLoadGroup::hasPurpose() { return !entity->getArgument(9)->isNull(); } +IfcLabel IfcStructuralLoadGroup::Purpose() { return *entity->getArgument(9); } +IfcStructuralResultGroup::list IfcStructuralLoadGroup::SourceOfResultGroup() { RETURN_INVERSE(IfcStructuralResultGroup) } +IfcStructuralAnalysisModel::list IfcStructuralLoadGroup::LoadGroupFor() { RETURN_INVERSE(IfcStructuralAnalysisModel) } +bool IfcStructuralLoadGroup::is(Type::Enum v) { return v == Type::IfcStructuralLoadGroup || IfcGroup::is(v); } +Type::Enum IfcStructuralLoadGroup::type() { return Type::IfcStructuralLoadGroup; } +Type::Enum IfcStructuralLoadGroup::Class() { return Type::IfcStructuralLoadGroup; } +IfcStructuralLoadGroup::IfcStructuralLoadGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadGroup)) throw; entity = e; } +// IfcStructuralLoadLinearForce +bool IfcStructuralLoadLinearForce::hasLinearForceX() { return !entity->getArgument(1)->isNull(); } +IfcLinearForceMeasure IfcStructuralLoadLinearForce::LinearForceX() { return *entity->getArgument(1); } +bool IfcStructuralLoadLinearForce::hasLinearForceY() { return !entity->getArgument(2)->isNull(); } +IfcLinearForceMeasure IfcStructuralLoadLinearForce::LinearForceY() { return *entity->getArgument(2); } +bool IfcStructuralLoadLinearForce::hasLinearForceZ() { return !entity->getArgument(3)->isNull(); } +IfcLinearForceMeasure IfcStructuralLoadLinearForce::LinearForceZ() { return *entity->getArgument(3); } +bool IfcStructuralLoadLinearForce::hasLinearMomentX() { return !entity->getArgument(4)->isNull(); } +IfcLinearMomentMeasure IfcStructuralLoadLinearForce::LinearMomentX() { return *entity->getArgument(4); } +bool IfcStructuralLoadLinearForce::hasLinearMomentY() { return !entity->getArgument(5)->isNull(); } +IfcLinearMomentMeasure IfcStructuralLoadLinearForce::LinearMomentY() { return *entity->getArgument(5); } +bool IfcStructuralLoadLinearForce::hasLinearMomentZ() { return !entity->getArgument(6)->isNull(); } +IfcLinearMomentMeasure IfcStructuralLoadLinearForce::LinearMomentZ() { return *entity->getArgument(6); } +bool IfcStructuralLoadLinearForce::is(Type::Enum v) { return v == Type::IfcStructuralLoadLinearForce || IfcStructuralLoadStatic::is(v); } +Type::Enum IfcStructuralLoadLinearForce::type() { return Type::IfcStructuralLoadLinearForce; } +Type::Enum IfcStructuralLoadLinearForce::Class() { return Type::IfcStructuralLoadLinearForce; } +IfcStructuralLoadLinearForce::IfcStructuralLoadLinearForce(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadLinearForce)) throw; entity = e; } +// IfcStructuralLoadPlanarForce +bool IfcStructuralLoadPlanarForce::hasPlanarForceX() { return !entity->getArgument(1)->isNull(); } +IfcPlanarForceMeasure IfcStructuralLoadPlanarForce::PlanarForceX() { return *entity->getArgument(1); } +bool IfcStructuralLoadPlanarForce::hasPlanarForceY() { return !entity->getArgument(2)->isNull(); } +IfcPlanarForceMeasure IfcStructuralLoadPlanarForce::PlanarForceY() { return *entity->getArgument(2); } +bool IfcStructuralLoadPlanarForce::hasPlanarForceZ() { return !entity->getArgument(3)->isNull(); } +IfcPlanarForceMeasure IfcStructuralLoadPlanarForce::PlanarForceZ() { return *entity->getArgument(3); } +bool IfcStructuralLoadPlanarForce::is(Type::Enum v) { return v == Type::IfcStructuralLoadPlanarForce || IfcStructuralLoadStatic::is(v); } +Type::Enum IfcStructuralLoadPlanarForce::type() { return Type::IfcStructuralLoadPlanarForce; } +Type::Enum IfcStructuralLoadPlanarForce::Class() { return Type::IfcStructuralLoadPlanarForce; } +IfcStructuralLoadPlanarForce::IfcStructuralLoadPlanarForce(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadPlanarForce)) throw; entity = e; } +// IfcStructuralLoadSingleDisplacement +bool IfcStructuralLoadSingleDisplacement::hasDisplacementX() { return !entity->getArgument(1)->isNull(); } +IfcLengthMeasure IfcStructuralLoadSingleDisplacement::DisplacementX() { return *entity->getArgument(1); } +bool IfcStructuralLoadSingleDisplacement::hasDisplacementY() { return !entity->getArgument(2)->isNull(); } +IfcLengthMeasure IfcStructuralLoadSingleDisplacement::DisplacementY() { return *entity->getArgument(2); } +bool IfcStructuralLoadSingleDisplacement::hasDisplacementZ() { return !entity->getArgument(3)->isNull(); } +IfcLengthMeasure IfcStructuralLoadSingleDisplacement::DisplacementZ() { return *entity->getArgument(3); } +bool IfcStructuralLoadSingleDisplacement::hasRotationalDisplacementRX() { return !entity->getArgument(4)->isNull(); } +IfcPlaneAngleMeasure IfcStructuralLoadSingleDisplacement::RotationalDisplacementRX() { return *entity->getArgument(4); } +bool IfcStructuralLoadSingleDisplacement::hasRotationalDisplacementRY() { return !entity->getArgument(5)->isNull(); } +IfcPlaneAngleMeasure IfcStructuralLoadSingleDisplacement::RotationalDisplacementRY() { return *entity->getArgument(5); } +bool IfcStructuralLoadSingleDisplacement::hasRotationalDisplacementRZ() { return !entity->getArgument(6)->isNull(); } +IfcPlaneAngleMeasure IfcStructuralLoadSingleDisplacement::RotationalDisplacementRZ() { return *entity->getArgument(6); } +bool IfcStructuralLoadSingleDisplacement::is(Type::Enum v) { return v == Type::IfcStructuralLoadSingleDisplacement || IfcStructuralLoadStatic::is(v); } +Type::Enum IfcStructuralLoadSingleDisplacement::type() { return Type::IfcStructuralLoadSingleDisplacement; } +Type::Enum IfcStructuralLoadSingleDisplacement::Class() { return Type::IfcStructuralLoadSingleDisplacement; } +IfcStructuralLoadSingleDisplacement::IfcStructuralLoadSingleDisplacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleDisplacement)) throw; entity = e; } +// IfcStructuralLoadSingleDisplacementDistortion +bool IfcStructuralLoadSingleDisplacementDistortion::hasDistortion() { return !entity->getArgument(7)->isNull(); } +IfcCurvatureMeasure IfcStructuralLoadSingleDisplacementDistortion::Distortion() { return *entity->getArgument(7); } +bool IfcStructuralLoadSingleDisplacementDistortion::is(Type::Enum v) { return v == Type::IfcStructuralLoadSingleDisplacementDistortion || IfcStructuralLoadSingleDisplacement::is(v); } +Type::Enum IfcStructuralLoadSingleDisplacementDistortion::type() { return Type::IfcStructuralLoadSingleDisplacementDistortion; } +Type::Enum IfcStructuralLoadSingleDisplacementDistortion::Class() { return Type::IfcStructuralLoadSingleDisplacementDistortion; } +IfcStructuralLoadSingleDisplacementDistortion::IfcStructuralLoadSingleDisplacementDistortion(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleDisplacementDistortion)) throw; entity = e; } +// IfcStructuralLoadSingleForce +bool IfcStructuralLoadSingleForce::hasForceX() { return !entity->getArgument(1)->isNull(); } +IfcForceMeasure IfcStructuralLoadSingleForce::ForceX() { return *entity->getArgument(1); } +bool IfcStructuralLoadSingleForce::hasForceY() { return !entity->getArgument(2)->isNull(); } +IfcForceMeasure IfcStructuralLoadSingleForce::ForceY() { return *entity->getArgument(2); } +bool IfcStructuralLoadSingleForce::hasForceZ() { return !entity->getArgument(3)->isNull(); } +IfcForceMeasure IfcStructuralLoadSingleForce::ForceZ() { return *entity->getArgument(3); } +bool IfcStructuralLoadSingleForce::hasMomentX() { return !entity->getArgument(4)->isNull(); } +IfcTorqueMeasure IfcStructuralLoadSingleForce::MomentX() { return *entity->getArgument(4); } +bool IfcStructuralLoadSingleForce::hasMomentY() { return !entity->getArgument(5)->isNull(); } +IfcTorqueMeasure IfcStructuralLoadSingleForce::MomentY() { return *entity->getArgument(5); } +bool IfcStructuralLoadSingleForce::hasMomentZ() { return !entity->getArgument(6)->isNull(); } +IfcTorqueMeasure IfcStructuralLoadSingleForce::MomentZ() { return *entity->getArgument(6); } +bool IfcStructuralLoadSingleForce::is(Type::Enum v) { return v == Type::IfcStructuralLoadSingleForce || IfcStructuralLoadStatic::is(v); } +Type::Enum IfcStructuralLoadSingleForce::type() { return Type::IfcStructuralLoadSingleForce; } +Type::Enum IfcStructuralLoadSingleForce::Class() { return Type::IfcStructuralLoadSingleForce; } +IfcStructuralLoadSingleForce::IfcStructuralLoadSingleForce(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleForce)) throw; entity = e; } +// IfcStructuralLoadSingleForceWarping +bool IfcStructuralLoadSingleForceWarping::hasWarpingMoment() { return !entity->getArgument(7)->isNull(); } +IfcWarpingMomentMeasure IfcStructuralLoadSingleForceWarping::WarpingMoment() { return *entity->getArgument(7); } +bool IfcStructuralLoadSingleForceWarping::is(Type::Enum v) { return v == Type::IfcStructuralLoadSingleForceWarping || IfcStructuralLoadSingleForce::is(v); } +Type::Enum IfcStructuralLoadSingleForceWarping::type() { return Type::IfcStructuralLoadSingleForceWarping; } +Type::Enum IfcStructuralLoadSingleForceWarping::Class() { return Type::IfcStructuralLoadSingleForceWarping; } +IfcStructuralLoadSingleForceWarping::IfcStructuralLoadSingleForceWarping(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleForceWarping)) throw; entity = e; } +// IfcStructuralLoadStatic +bool IfcStructuralLoadStatic::is(Type::Enum v) { return v == Type::IfcStructuralLoadStatic || IfcStructuralLoad::is(v); } +Type::Enum IfcStructuralLoadStatic::type() { return Type::IfcStructuralLoadStatic; } +Type::Enum IfcStructuralLoadStatic::Class() { return Type::IfcStructuralLoadStatic; } +IfcStructuralLoadStatic::IfcStructuralLoadStatic(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadStatic)) throw; entity = e; } +// IfcStructuralLoadTemperature +bool IfcStructuralLoadTemperature::hasDeltaT_Constant() { return !entity->getArgument(1)->isNull(); } +IfcThermodynamicTemperatureMeasure IfcStructuralLoadTemperature::DeltaT_Constant() { return *entity->getArgument(1); } +bool IfcStructuralLoadTemperature::hasDeltaT_Y() { return !entity->getArgument(2)->isNull(); } +IfcThermodynamicTemperatureMeasure IfcStructuralLoadTemperature::DeltaT_Y() { return *entity->getArgument(2); } +bool IfcStructuralLoadTemperature::hasDeltaT_Z() { return !entity->getArgument(3)->isNull(); } +IfcThermodynamicTemperatureMeasure IfcStructuralLoadTemperature::DeltaT_Z() { return *entity->getArgument(3); } +bool IfcStructuralLoadTemperature::is(Type::Enum v) { return v == Type::IfcStructuralLoadTemperature || IfcStructuralLoadStatic::is(v); } +Type::Enum IfcStructuralLoadTemperature::type() { return Type::IfcStructuralLoadTemperature; } +Type::Enum IfcStructuralLoadTemperature::Class() { return Type::IfcStructuralLoadTemperature; } +IfcStructuralLoadTemperature::IfcStructuralLoadTemperature(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadTemperature)) throw; entity = e; } +// IfcStructuralMember +IfcRelConnectsStructuralElement::list IfcStructuralMember::ReferencesElement() { RETURN_INVERSE(IfcRelConnectsStructuralElement) } +IfcRelConnectsStructuralMember::list IfcStructuralMember::ConnectedBy() { RETURN_INVERSE(IfcRelConnectsStructuralMember) } +bool IfcStructuralMember::is(Type::Enum v) { return v == Type::IfcStructuralMember || IfcStructuralItem::is(v); } +Type::Enum IfcStructuralMember::type() { return Type::IfcStructuralMember; } +Type::Enum IfcStructuralMember::Class() { return Type::IfcStructuralMember; } +IfcStructuralMember::IfcStructuralMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralMember)) throw; entity = e; } +// IfcStructuralPlanarAction +IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralPlanarAction::ProjectedOrTrue() { return IfcProjectedOrTrueLengthEnum::FromString(*entity->getArgument(11)); } +bool IfcStructuralPlanarAction::is(Type::Enum v) { return v == Type::IfcStructuralPlanarAction || IfcStructuralAction::is(v); } +Type::Enum IfcStructuralPlanarAction::type() { return Type::IfcStructuralPlanarAction; } +Type::Enum IfcStructuralPlanarAction::Class() { return Type::IfcStructuralPlanarAction; } +IfcStructuralPlanarAction::IfcStructuralPlanarAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPlanarAction)) throw; entity = e; } +// IfcStructuralPlanarActionVarying +SHARED_PTR IfcStructuralPlanarActionVarying::VaryingAppliedLoadLocation() { return reinterpret_pointer_cast(*entity->getArgument(12)); } +SHARED_PTR< IfcTemplatedEntityList > IfcStructuralPlanarActionVarying::SubsequentAppliedLoads() { RETURN_AS_LIST(IfcStructuralLoad,13) } +bool IfcStructuralPlanarActionVarying::is(Type::Enum v) { return v == Type::IfcStructuralPlanarActionVarying || IfcStructuralPlanarAction::is(v); } +Type::Enum IfcStructuralPlanarActionVarying::type() { return Type::IfcStructuralPlanarActionVarying; } +Type::Enum IfcStructuralPlanarActionVarying::Class() { return Type::IfcStructuralPlanarActionVarying; } +IfcStructuralPlanarActionVarying::IfcStructuralPlanarActionVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPlanarActionVarying)) throw; entity = e; } +// IfcStructuralPointAction +bool IfcStructuralPointAction::is(Type::Enum v) { return v == Type::IfcStructuralPointAction || IfcStructuralAction::is(v); } +Type::Enum IfcStructuralPointAction::type() { return Type::IfcStructuralPointAction; } +Type::Enum IfcStructuralPointAction::Class() { return Type::IfcStructuralPointAction; } +IfcStructuralPointAction::IfcStructuralPointAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPointAction)) throw; entity = e; } +// IfcStructuralPointConnection +bool IfcStructuralPointConnection::is(Type::Enum v) { return v == Type::IfcStructuralPointConnection || IfcStructuralConnection::is(v); } +Type::Enum IfcStructuralPointConnection::type() { return Type::IfcStructuralPointConnection; } +Type::Enum IfcStructuralPointConnection::Class() { return Type::IfcStructuralPointConnection; } +IfcStructuralPointConnection::IfcStructuralPointConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPointConnection)) throw; entity = e; } +// IfcStructuralPointReaction +bool IfcStructuralPointReaction::is(Type::Enum v) { return v == Type::IfcStructuralPointReaction || IfcStructuralReaction::is(v); } +Type::Enum IfcStructuralPointReaction::type() { return Type::IfcStructuralPointReaction; } +Type::Enum IfcStructuralPointReaction::Class() { return Type::IfcStructuralPointReaction; } +IfcStructuralPointReaction::IfcStructuralPointReaction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPointReaction)) throw; entity = e; } +// IfcStructuralProfileProperties +bool IfcStructuralProfileProperties::hasTorsionalConstantX() { return !entity->getArgument(7)->isNull(); } +IfcMomentOfInertiaMeasure IfcStructuralProfileProperties::TorsionalConstantX() { return *entity->getArgument(7); } +bool IfcStructuralProfileProperties::hasMomentOfInertiaYZ() { return !entity->getArgument(8)->isNull(); } +IfcMomentOfInertiaMeasure IfcStructuralProfileProperties::MomentOfInertiaYZ() { return *entity->getArgument(8); } +bool IfcStructuralProfileProperties::hasMomentOfInertiaY() { return !entity->getArgument(9)->isNull(); } +IfcMomentOfInertiaMeasure IfcStructuralProfileProperties::MomentOfInertiaY() { return *entity->getArgument(9); } +bool IfcStructuralProfileProperties::hasMomentOfInertiaZ() { return !entity->getArgument(10)->isNull(); } +IfcMomentOfInertiaMeasure IfcStructuralProfileProperties::MomentOfInertiaZ() { return *entity->getArgument(10); } +bool IfcStructuralProfileProperties::hasWarpingConstant() { return !entity->getArgument(11)->isNull(); } +IfcWarpingConstantMeasure IfcStructuralProfileProperties::WarpingConstant() { return *entity->getArgument(11); } +bool IfcStructuralProfileProperties::hasShearCentreZ() { return !entity->getArgument(12)->isNull(); } +IfcLengthMeasure IfcStructuralProfileProperties::ShearCentreZ() { return *entity->getArgument(12); } +bool IfcStructuralProfileProperties::hasShearCentreY() { return !entity->getArgument(13)->isNull(); } +IfcLengthMeasure IfcStructuralProfileProperties::ShearCentreY() { return *entity->getArgument(13); } +bool IfcStructuralProfileProperties::hasShearDeformationAreaZ() { return !entity->getArgument(14)->isNull(); } +IfcAreaMeasure IfcStructuralProfileProperties::ShearDeformationAreaZ() { return *entity->getArgument(14); } +bool IfcStructuralProfileProperties::hasShearDeformationAreaY() { return !entity->getArgument(15)->isNull(); } +IfcAreaMeasure IfcStructuralProfileProperties::ShearDeformationAreaY() { return *entity->getArgument(15); } +bool IfcStructuralProfileProperties::hasMaximumSectionModulusY() { return !entity->getArgument(16)->isNull(); } +IfcSectionModulusMeasure IfcStructuralProfileProperties::MaximumSectionModulusY() { return *entity->getArgument(16); } +bool IfcStructuralProfileProperties::hasMinimumSectionModulusY() { return !entity->getArgument(17)->isNull(); } +IfcSectionModulusMeasure IfcStructuralProfileProperties::MinimumSectionModulusY() { return *entity->getArgument(17); } +bool IfcStructuralProfileProperties::hasMaximumSectionModulusZ() { return !entity->getArgument(18)->isNull(); } +IfcSectionModulusMeasure IfcStructuralProfileProperties::MaximumSectionModulusZ() { return *entity->getArgument(18); } +bool IfcStructuralProfileProperties::hasMinimumSectionModulusZ() { return !entity->getArgument(19)->isNull(); } +IfcSectionModulusMeasure IfcStructuralProfileProperties::MinimumSectionModulusZ() { return *entity->getArgument(19); } +bool IfcStructuralProfileProperties::hasTorsionalSectionModulus() { return !entity->getArgument(20)->isNull(); } +IfcSectionModulusMeasure IfcStructuralProfileProperties::TorsionalSectionModulus() { return *entity->getArgument(20); } +bool IfcStructuralProfileProperties::hasCentreOfGravityInX() { return !entity->getArgument(21)->isNull(); } +IfcLengthMeasure IfcStructuralProfileProperties::CentreOfGravityInX() { return *entity->getArgument(21); } +bool IfcStructuralProfileProperties::hasCentreOfGravityInY() { return !entity->getArgument(22)->isNull(); } +IfcLengthMeasure IfcStructuralProfileProperties::CentreOfGravityInY() { return *entity->getArgument(22); } +bool IfcStructuralProfileProperties::is(Type::Enum v) { return v == Type::IfcStructuralProfileProperties || IfcGeneralProfileProperties::is(v); } +Type::Enum IfcStructuralProfileProperties::type() { return Type::IfcStructuralProfileProperties; } +Type::Enum IfcStructuralProfileProperties::Class() { return Type::IfcStructuralProfileProperties; } +IfcStructuralProfileProperties::IfcStructuralProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralProfileProperties)) throw; entity = e; } +// IfcStructuralReaction +IfcStructuralAction::list IfcStructuralReaction::Causes() { RETURN_INVERSE(IfcStructuralAction) } +bool IfcStructuralReaction::is(Type::Enum v) { return v == Type::IfcStructuralReaction || IfcStructuralActivity::is(v); } +Type::Enum IfcStructuralReaction::type() { return Type::IfcStructuralReaction; } +Type::Enum IfcStructuralReaction::Class() { return Type::IfcStructuralReaction; } +IfcStructuralReaction::IfcStructuralReaction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralReaction)) throw; entity = e; } +// IfcStructuralResultGroup +IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum IfcStructuralResultGroup::TheoryType() { return IfcAnalysisTheoryTypeEnum::FromString(*entity->getArgument(5)); } +bool IfcStructuralResultGroup::hasResultForLoadGroup() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR IfcStructuralResultGroup::ResultForLoadGroup() { return reinterpret_pointer_cast(*entity->getArgument(6)); } +bool IfcStructuralResultGroup::IsLinear() { return *entity->getArgument(7); } +IfcStructuralAnalysisModel::list IfcStructuralResultGroup::ResultGroupFor() { RETURN_INVERSE(IfcStructuralAnalysisModel) } +bool IfcStructuralResultGroup::is(Type::Enum v) { return v == Type::IfcStructuralResultGroup || IfcGroup::is(v); } +Type::Enum IfcStructuralResultGroup::type() { return Type::IfcStructuralResultGroup; } +Type::Enum IfcStructuralResultGroup::Class() { return Type::IfcStructuralResultGroup; } +IfcStructuralResultGroup::IfcStructuralResultGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralResultGroup)) throw; entity = e; } +// IfcStructuralSteelProfileProperties +bool IfcStructuralSteelProfileProperties::hasShearAreaZ() { return !entity->getArgument(23)->isNull(); } +IfcAreaMeasure IfcStructuralSteelProfileProperties::ShearAreaZ() { return *entity->getArgument(23); } +bool IfcStructuralSteelProfileProperties::hasShearAreaY() { return !entity->getArgument(24)->isNull(); } +IfcAreaMeasure IfcStructuralSteelProfileProperties::ShearAreaY() { return *entity->getArgument(24); } +bool IfcStructuralSteelProfileProperties::hasPlasticShapeFactorY() { return !entity->getArgument(25)->isNull(); } +IfcPositiveRatioMeasure IfcStructuralSteelProfileProperties::PlasticShapeFactorY() { return *entity->getArgument(25); } +bool IfcStructuralSteelProfileProperties::hasPlasticShapeFactorZ() { return !entity->getArgument(26)->isNull(); } +IfcPositiveRatioMeasure IfcStructuralSteelProfileProperties::PlasticShapeFactorZ() { return *entity->getArgument(26); } +bool IfcStructuralSteelProfileProperties::is(Type::Enum v) { return v == Type::IfcStructuralSteelProfileProperties || IfcStructuralProfileProperties::is(v); } +Type::Enum IfcStructuralSteelProfileProperties::type() { return Type::IfcStructuralSteelProfileProperties; } +Type::Enum IfcStructuralSteelProfileProperties::Class() { return Type::IfcStructuralSteelProfileProperties; } +IfcStructuralSteelProfileProperties::IfcStructuralSteelProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSteelProfileProperties)) throw; entity = e; } +// IfcStructuralSurfaceConnection +bool IfcStructuralSurfaceConnection::is(Type::Enum v) { return v == Type::IfcStructuralSurfaceConnection || IfcStructuralConnection::is(v); } +Type::Enum IfcStructuralSurfaceConnection::type() { return Type::IfcStructuralSurfaceConnection; } +Type::Enum IfcStructuralSurfaceConnection::Class() { return Type::IfcStructuralSurfaceConnection; } +IfcStructuralSurfaceConnection::IfcStructuralSurfaceConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSurfaceConnection)) throw; entity = e; } +// IfcStructuralSurfaceMember +IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum IfcStructuralSurfaceMember::PredefinedType() { return IfcStructuralSurfaceTypeEnum::FromString(*entity->getArgument(7)); } +bool IfcStructuralSurfaceMember::hasThickness() { return !entity->getArgument(8)->isNull(); } +IfcPositiveLengthMeasure IfcStructuralSurfaceMember::Thickness() { return *entity->getArgument(8); } +bool IfcStructuralSurfaceMember::is(Type::Enum v) { return v == Type::IfcStructuralSurfaceMember || IfcStructuralMember::is(v); } +Type::Enum IfcStructuralSurfaceMember::type() { return Type::IfcStructuralSurfaceMember; } +Type::Enum IfcStructuralSurfaceMember::Class() { return Type::IfcStructuralSurfaceMember; } +IfcStructuralSurfaceMember::IfcStructuralSurfaceMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSurfaceMember)) throw; entity = e; } +// IfcStructuralSurfaceMemberVarying +std::vector IfcStructuralSurfaceMemberVarying::SubsequentThickness() { return *entity->getArgument(9); } +SHARED_PTR IfcStructuralSurfaceMemberVarying::VaryingThicknessLocation() { return reinterpret_pointer_cast(*entity->getArgument(10)); } +bool IfcStructuralSurfaceMemberVarying::is(Type::Enum v) { return v == Type::IfcStructuralSurfaceMemberVarying || IfcStructuralSurfaceMember::is(v); } +Type::Enum IfcStructuralSurfaceMemberVarying::type() { return Type::IfcStructuralSurfaceMemberVarying; } +Type::Enum IfcStructuralSurfaceMemberVarying::Class() { return Type::IfcStructuralSurfaceMemberVarying; } +IfcStructuralSurfaceMemberVarying::IfcStructuralSurfaceMemberVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSurfaceMemberVarying)) throw; entity = e; } +// IfcStructuredDimensionCallout +bool IfcStructuredDimensionCallout::is(Type::Enum v) { return v == Type::IfcStructuredDimensionCallout || IfcDraughtingCallout::is(v); } +Type::Enum IfcStructuredDimensionCallout::type() { return Type::IfcStructuredDimensionCallout; } +Type::Enum IfcStructuredDimensionCallout::Class() { return Type::IfcStructuredDimensionCallout; } +IfcStructuredDimensionCallout::IfcStructuredDimensionCallout(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuredDimensionCallout)) throw; entity = e; } +// IfcStyleModel +bool IfcStyleModel::is(Type::Enum v) { return v == Type::IfcStyleModel || IfcRepresentation::is(v); } +Type::Enum IfcStyleModel::type() { return Type::IfcStyleModel; } +Type::Enum IfcStyleModel::Class() { return Type::IfcStyleModel; } +IfcStyleModel::IfcStyleModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcStyleModel)) throw; entity = e; } +// IfcStyledItem +bool IfcStyledItem::hasItem() { return !entity->getArgument(0)->isNull(); } +SHARED_PTR IfcStyledItem::Item() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR< IfcTemplatedEntityList > IfcStyledItem::Styles() { RETURN_AS_LIST(IfcPresentationStyleAssignment,1) } +bool IfcStyledItem::hasName() { return !entity->getArgument(2)->isNull(); } +IfcLabel IfcStyledItem::Name() { return *entity->getArgument(2); } +bool IfcStyledItem::is(Type::Enum v) { return v == Type::IfcStyledItem || IfcRepresentationItem::is(v); } +Type::Enum IfcStyledItem::type() { return Type::IfcStyledItem; } +Type::Enum IfcStyledItem::Class() { return Type::IfcStyledItem; } +IfcStyledItem::IfcStyledItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcStyledItem)) throw; entity = e; } +// IfcStyledRepresentation +bool IfcStyledRepresentation::is(Type::Enum v) { return v == Type::IfcStyledRepresentation || IfcStyleModel::is(v); } +Type::Enum IfcStyledRepresentation::type() { return Type::IfcStyledRepresentation; } +Type::Enum IfcStyledRepresentation::Class() { return Type::IfcStyledRepresentation; } +IfcStyledRepresentation::IfcStyledRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcStyledRepresentation)) throw; entity = e; } +// IfcSubContractResource +bool IfcSubContractResource::hasSubContractor() { return !entity->getArgument(9)->isNull(); } +IfcActorSelect IfcSubContractResource::SubContractor() { return *entity->getArgument(9); } +bool IfcSubContractResource::hasJobDescription() { return !entity->getArgument(10)->isNull(); } +IfcText IfcSubContractResource::JobDescription() { return *entity->getArgument(10); } +bool IfcSubContractResource::is(Type::Enum v) { return v == Type::IfcSubContractResource || IfcConstructionResource::is(v); } +Type::Enum IfcSubContractResource::type() { return Type::IfcSubContractResource; } +Type::Enum IfcSubContractResource::Class() { return Type::IfcSubContractResource; } +IfcSubContractResource::IfcSubContractResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcSubContractResource)) throw; entity = e; } +// IfcSubedge +SHARED_PTR IfcSubedge::ParentEdge() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcSubedge::is(Type::Enum v) { return v == Type::IfcSubedge || IfcEdge::is(v); } +Type::Enum IfcSubedge::type() { return Type::IfcSubedge; } +Type::Enum IfcSubedge::Class() { return Type::IfcSubedge; } +IfcSubedge::IfcSubedge(IfcAbstractEntityPtr e) { if (!is(Type::IfcSubedge)) throw; entity = e; } +// IfcSurface +bool IfcSurface::is(Type::Enum v) { return v == Type::IfcSurface || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcSurface::type() { return Type::IfcSurface; } +Type::Enum IfcSurface::Class() { return Type::IfcSurface; } +IfcSurface::IfcSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurface)) throw; entity = e; } +// IfcSurfaceCurveSweptAreaSolid +SHARED_PTR IfcSurfaceCurveSweptAreaSolid::Directrix() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +IfcParameterValue IfcSurfaceCurveSweptAreaSolid::StartParam() { return *entity->getArgument(3); } +IfcParameterValue IfcSurfaceCurveSweptAreaSolid::EndParam() { return *entity->getArgument(4); } +SHARED_PTR IfcSurfaceCurveSweptAreaSolid::ReferenceSurface() { return reinterpret_pointer_cast(*entity->getArgument(5)); } +bool IfcSurfaceCurveSweptAreaSolid::is(Type::Enum v) { return v == Type::IfcSurfaceCurveSweptAreaSolid || IfcSweptAreaSolid::is(v); } +Type::Enum IfcSurfaceCurveSweptAreaSolid::type() { return Type::IfcSurfaceCurveSweptAreaSolid; } +Type::Enum IfcSurfaceCurveSweptAreaSolid::Class() { return Type::IfcSurfaceCurveSweptAreaSolid; } +IfcSurfaceCurveSweptAreaSolid::IfcSurfaceCurveSweptAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceCurveSweptAreaSolid)) throw; entity = e; } +// IfcSurfaceOfLinearExtrusion +SHARED_PTR IfcSurfaceOfLinearExtrusion::ExtrudedDirection() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +IfcLengthMeasure IfcSurfaceOfLinearExtrusion::Depth() { return *entity->getArgument(3); } +bool IfcSurfaceOfLinearExtrusion::is(Type::Enum v) { return v == Type::IfcSurfaceOfLinearExtrusion || IfcSweptSurface::is(v); } +Type::Enum IfcSurfaceOfLinearExtrusion::type() { return Type::IfcSurfaceOfLinearExtrusion; } +Type::Enum IfcSurfaceOfLinearExtrusion::Class() { return Type::IfcSurfaceOfLinearExtrusion; } +IfcSurfaceOfLinearExtrusion::IfcSurfaceOfLinearExtrusion(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceOfLinearExtrusion)) throw; entity = e; } +// IfcSurfaceOfRevolution +SHARED_PTR IfcSurfaceOfRevolution::AxisPosition() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +bool IfcSurfaceOfRevolution::is(Type::Enum v) { return v == Type::IfcSurfaceOfRevolution || IfcSweptSurface::is(v); } +Type::Enum IfcSurfaceOfRevolution::type() { return Type::IfcSurfaceOfRevolution; } +Type::Enum IfcSurfaceOfRevolution::Class() { return Type::IfcSurfaceOfRevolution; } +IfcSurfaceOfRevolution::IfcSurfaceOfRevolution(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceOfRevolution)) throw; entity = e; } +// IfcSurfaceStyle +IfcSurfaceSide::IfcSurfaceSide IfcSurfaceStyle::Side() { return IfcSurfaceSide::FromString(*entity->getArgument(1)); } +SHARED_PTR< IfcTemplatedEntityList > IfcSurfaceStyle::Styles() { RETURN_AS_LIST(IfcAbstractSelect,2) } +bool IfcSurfaceStyle::is(Type::Enum v) { return v == Type::IfcSurfaceStyle || IfcPresentationStyle::is(v); } +Type::Enum IfcSurfaceStyle::type() { return Type::IfcSurfaceStyle; } +Type::Enum IfcSurfaceStyle::Class() { return Type::IfcSurfaceStyle; } +IfcSurfaceStyle::IfcSurfaceStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyle)) throw; entity = e; } +// IfcSurfaceStyleLighting +SHARED_PTR IfcSurfaceStyleLighting::DiffuseTransmissionColour() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcSurfaceStyleLighting::DiffuseReflectionColour() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +SHARED_PTR IfcSurfaceStyleLighting::TransmissionColour() { return reinterpret_pointer_cast(*entity->getArgument(2)); } +SHARED_PTR IfcSurfaceStyleLighting::ReflectanceColour() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcSurfaceStyleLighting::is(Type::Enum v) { return v == Type::IfcSurfaceStyleLighting; } +Type::Enum IfcSurfaceStyleLighting::type() { return Type::IfcSurfaceStyleLighting; } +Type::Enum IfcSurfaceStyleLighting::Class() { return Type::IfcSurfaceStyleLighting; } +IfcSurfaceStyleLighting::IfcSurfaceStyleLighting(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleLighting)) throw; entity = e; } +// IfcSurfaceStyleRefraction +bool IfcSurfaceStyleRefraction::hasRefractionIndex() { return !entity->getArgument(0)->isNull(); } +IfcReal IfcSurfaceStyleRefraction::RefractionIndex() { return *entity->getArgument(0); } +bool IfcSurfaceStyleRefraction::hasDispersionFactor() { return !entity->getArgument(1)->isNull(); } +IfcReal IfcSurfaceStyleRefraction::DispersionFactor() { return *entity->getArgument(1); } +bool IfcSurfaceStyleRefraction::is(Type::Enum v) { return v == Type::IfcSurfaceStyleRefraction; } +Type::Enum IfcSurfaceStyleRefraction::type() { return Type::IfcSurfaceStyleRefraction; } +Type::Enum IfcSurfaceStyleRefraction::Class() { return Type::IfcSurfaceStyleRefraction; } +IfcSurfaceStyleRefraction::IfcSurfaceStyleRefraction(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleRefraction)) throw; entity = e; } +// IfcSurfaceStyleRendering +bool IfcSurfaceStyleRendering::hasTransparency() { return !entity->getArgument(1)->isNull(); } +IfcNormalisedRatioMeasure IfcSurfaceStyleRendering::Transparency() { return *entity->getArgument(1); } +bool IfcSurfaceStyleRendering::hasDiffuseColour() { return !entity->getArgument(2)->isNull(); } +IfcColourOrFactor IfcSurfaceStyleRendering::DiffuseColour() { return *entity->getArgument(2); } +bool IfcSurfaceStyleRendering::hasTransmissionColour() { return !entity->getArgument(3)->isNull(); } +IfcColourOrFactor IfcSurfaceStyleRendering::TransmissionColour() { return *entity->getArgument(3); } +bool IfcSurfaceStyleRendering::hasDiffuseTransmissionColour() { return !entity->getArgument(4)->isNull(); } +IfcColourOrFactor IfcSurfaceStyleRendering::DiffuseTransmissionColour() { return *entity->getArgument(4); } +bool IfcSurfaceStyleRendering::hasReflectionColour() { return !entity->getArgument(5)->isNull(); } +IfcColourOrFactor IfcSurfaceStyleRendering::ReflectionColour() { return *entity->getArgument(5); } +bool IfcSurfaceStyleRendering::hasSpecularColour() { return !entity->getArgument(6)->isNull(); } +IfcColourOrFactor IfcSurfaceStyleRendering::SpecularColour() { return *entity->getArgument(6); } +bool IfcSurfaceStyleRendering::hasSpecularHighlight() { return !entity->getArgument(7)->isNull(); } +IfcSpecularHighlightSelect IfcSurfaceStyleRendering::SpecularHighlight() { return *entity->getArgument(7); } +IfcReflectanceMethodEnum::IfcReflectanceMethodEnum IfcSurfaceStyleRendering::ReflectanceMethod() { return IfcReflectanceMethodEnum::FromString(*entity->getArgument(8)); } +bool IfcSurfaceStyleRendering::is(Type::Enum v) { return v == Type::IfcSurfaceStyleRendering || IfcSurfaceStyleShading::is(v); } +Type::Enum IfcSurfaceStyleRendering::type() { return Type::IfcSurfaceStyleRendering; } +Type::Enum IfcSurfaceStyleRendering::Class() { return Type::IfcSurfaceStyleRendering; } +IfcSurfaceStyleRendering::IfcSurfaceStyleRendering(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleRendering)) throw; entity = e; } +// IfcSurfaceStyleShading +SHARED_PTR IfcSurfaceStyleShading::SurfaceColour() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcSurfaceStyleShading::is(Type::Enum v) { return v == Type::IfcSurfaceStyleShading; } +Type::Enum IfcSurfaceStyleShading::type() { return Type::IfcSurfaceStyleShading; } +Type::Enum IfcSurfaceStyleShading::Class() { return Type::IfcSurfaceStyleShading; } +IfcSurfaceStyleShading::IfcSurfaceStyleShading(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleShading)) throw; entity = e; } +// IfcSurfaceStyleWithTextures +SHARED_PTR< IfcTemplatedEntityList > IfcSurfaceStyleWithTextures::Textures() { RETURN_AS_LIST(IfcSurfaceTexture,0) } +bool IfcSurfaceStyleWithTextures::is(Type::Enum v) { return v == Type::IfcSurfaceStyleWithTextures; } +Type::Enum IfcSurfaceStyleWithTextures::type() { return Type::IfcSurfaceStyleWithTextures; } +Type::Enum IfcSurfaceStyleWithTextures::Class() { return Type::IfcSurfaceStyleWithTextures; } +IfcSurfaceStyleWithTextures::IfcSurfaceStyleWithTextures(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleWithTextures)) throw; entity = e; } +// IfcSurfaceTexture +bool IfcSurfaceTexture::RepeatS() { return *entity->getArgument(0); } +bool IfcSurfaceTexture::RepeatT() { return *entity->getArgument(1); } +IfcSurfaceTextureEnum::IfcSurfaceTextureEnum IfcSurfaceTexture::TextureType() { return IfcSurfaceTextureEnum::FromString(*entity->getArgument(2)); } +bool IfcSurfaceTexture::hasTextureTransform() { return !entity->getArgument(3)->isNull(); } +SHARED_PTR IfcSurfaceTexture::TextureTransform() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcSurfaceTexture::is(Type::Enum v) { return v == Type::IfcSurfaceTexture; } +Type::Enum IfcSurfaceTexture::type() { return Type::IfcSurfaceTexture; } +Type::Enum IfcSurfaceTexture::Class() { return Type::IfcSurfaceTexture; } +IfcSurfaceTexture::IfcSurfaceTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceTexture)) throw; entity = e; } +// IfcSweptAreaSolid +SHARED_PTR IfcSweptAreaSolid::SweptArea() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcSweptAreaSolid::Position() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcSweptAreaSolid::is(Type::Enum v) { return v == Type::IfcSweptAreaSolid || IfcSolidModel::is(v); } +Type::Enum IfcSweptAreaSolid::type() { return Type::IfcSweptAreaSolid; } +Type::Enum IfcSweptAreaSolid::Class() { return Type::IfcSweptAreaSolid; } +IfcSweptAreaSolid::IfcSweptAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcSweptAreaSolid)) throw; entity = e; } +// IfcSweptDiskSolid +SHARED_PTR IfcSweptDiskSolid::Directrix() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcPositiveLengthMeasure IfcSweptDiskSolid::Radius() { return *entity->getArgument(1); } +bool IfcSweptDiskSolid::hasInnerRadius() { return !entity->getArgument(2)->isNull(); } +IfcPositiveLengthMeasure IfcSweptDiskSolid::InnerRadius() { return *entity->getArgument(2); } +IfcParameterValue IfcSweptDiskSolid::StartParam() { return *entity->getArgument(3); } +IfcParameterValue IfcSweptDiskSolid::EndParam() { return *entity->getArgument(4); } +bool IfcSweptDiskSolid::is(Type::Enum v) { return v == Type::IfcSweptDiskSolid || IfcSolidModel::is(v); } +Type::Enum IfcSweptDiskSolid::type() { return Type::IfcSweptDiskSolid; } +Type::Enum IfcSweptDiskSolid::Class() { return Type::IfcSweptDiskSolid; } +IfcSweptDiskSolid::IfcSweptDiskSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcSweptDiskSolid)) throw; entity = e; } +// IfcSweptSurface +SHARED_PTR IfcSweptSurface::SweptCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR IfcSweptSurface::Position() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcSweptSurface::is(Type::Enum v) { return v == Type::IfcSweptSurface || IfcSurface::is(v); } +Type::Enum IfcSweptSurface::type() { return Type::IfcSweptSurface; } +Type::Enum IfcSweptSurface::Class() { return Type::IfcSweptSurface; } +IfcSweptSurface::IfcSweptSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcSweptSurface)) throw; entity = e; } +// IfcSwitchingDeviceType +IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum IfcSwitchingDeviceType::PredefinedType() { return IfcSwitchingDeviceTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcSwitchingDeviceType::is(Type::Enum v) { return v == Type::IfcSwitchingDeviceType || IfcFlowControllerType::is(v); } +Type::Enum IfcSwitchingDeviceType::type() { return Type::IfcSwitchingDeviceType; } +Type::Enum IfcSwitchingDeviceType::Class() { return Type::IfcSwitchingDeviceType; } +IfcSwitchingDeviceType::IfcSwitchingDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSwitchingDeviceType)) throw; entity = e; } +// IfcSymbolStyle +IfcSymbolStyleSelect IfcSymbolStyle::StyleOfSymbol() { return *entity->getArgument(1); } +bool IfcSymbolStyle::is(Type::Enum v) { return v == Type::IfcSymbolStyle || IfcPresentationStyle::is(v); } +Type::Enum IfcSymbolStyle::type() { return Type::IfcSymbolStyle; } +Type::Enum IfcSymbolStyle::Class() { return Type::IfcSymbolStyle; } +IfcSymbolStyle::IfcSymbolStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcSymbolStyle)) throw; entity = e; } +// IfcSystem +IfcRelServicesBuildings::list IfcSystem::ServicesBuildings() { RETURN_INVERSE(IfcRelServicesBuildings) } +bool IfcSystem::is(Type::Enum v) { return v == Type::IfcSystem || IfcGroup::is(v); } +Type::Enum IfcSystem::type() { return Type::IfcSystem; } +Type::Enum IfcSystem::Class() { return Type::IfcSystem; } +IfcSystem::IfcSystem(IfcAbstractEntityPtr e) { if (!is(Type::IfcSystem)) throw; entity = e; } +// IfcSystemFurnitureElementType +bool IfcSystemFurnitureElementType::is(Type::Enum v) { return v == Type::IfcSystemFurnitureElementType || IfcFurnishingElementType::is(v); } +Type::Enum IfcSystemFurnitureElementType::type() { return Type::IfcSystemFurnitureElementType; } +Type::Enum IfcSystemFurnitureElementType::Class() { return Type::IfcSystemFurnitureElementType; } +IfcSystemFurnitureElementType::IfcSystemFurnitureElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSystemFurnitureElementType)) throw; entity = e; } +// IfcTShapeProfileDef +IfcPositiveLengthMeasure IfcTShapeProfileDef::Depth() { return *entity->getArgument(3); } +IfcPositiveLengthMeasure IfcTShapeProfileDef::FlangeWidth() { return *entity->getArgument(4); } +IfcPositiveLengthMeasure IfcTShapeProfileDef::WebThickness() { return *entity->getArgument(5); } +IfcPositiveLengthMeasure IfcTShapeProfileDef::FlangeThickness() { return *entity->getArgument(6); } +bool IfcTShapeProfileDef::hasFilletRadius() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcTShapeProfileDef::FilletRadius() { return *entity->getArgument(7); } +bool IfcTShapeProfileDef::hasFlangeEdgeRadius() { return !entity->getArgument(8)->isNull(); } +IfcPositiveLengthMeasure IfcTShapeProfileDef::FlangeEdgeRadius() { return *entity->getArgument(8); } +bool IfcTShapeProfileDef::hasWebEdgeRadius() { return !entity->getArgument(9)->isNull(); } +IfcPositiveLengthMeasure IfcTShapeProfileDef::WebEdgeRadius() { return *entity->getArgument(9); } +bool IfcTShapeProfileDef::hasWebSlope() { return !entity->getArgument(10)->isNull(); } +IfcPlaneAngleMeasure IfcTShapeProfileDef::WebSlope() { return *entity->getArgument(10); } +bool IfcTShapeProfileDef::hasFlangeSlope() { return !entity->getArgument(11)->isNull(); } +IfcPlaneAngleMeasure IfcTShapeProfileDef::FlangeSlope() { return *entity->getArgument(11); } +bool IfcTShapeProfileDef::hasCentreOfGravityInY() { return !entity->getArgument(12)->isNull(); } +IfcPositiveLengthMeasure IfcTShapeProfileDef::CentreOfGravityInY() { return *entity->getArgument(12); } +bool IfcTShapeProfileDef::is(Type::Enum v) { return v == Type::IfcTShapeProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcTShapeProfileDef::type() { return Type::IfcTShapeProfileDef; } +Type::Enum IfcTShapeProfileDef::Class() { return Type::IfcTShapeProfileDef; } +IfcTShapeProfileDef::IfcTShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcTShapeProfileDef)) throw; entity = e; } +// IfcTable +std::string IfcTable::Name() { return *entity->getArgument(0); } +SHARED_PTR< IfcTemplatedEntityList > IfcTable::Rows() { RETURN_AS_LIST(IfcTableRow,1) } +bool IfcTable::is(Type::Enum v) { return v == Type::IfcTable; } +Type::Enum IfcTable::type() { return Type::IfcTable; } +Type::Enum IfcTable::Class() { return Type::IfcTable; } +IfcTable::IfcTable(IfcAbstractEntityPtr e) { if (!is(Type::IfcTable)) throw; entity = e; } +// IfcTableRow +SHARED_PTR< IfcTemplatedEntityList > IfcTableRow::RowCells() { RETURN_AS_LIST(IfcAbstractSelect,0) } +bool IfcTableRow::IsHeading() { return *entity->getArgument(1); } +IfcTable::list IfcTableRow::OfTable() { RETURN_INVERSE(IfcTable) } +bool IfcTableRow::is(Type::Enum v) { return v == Type::IfcTableRow; } +Type::Enum IfcTableRow::type() { return Type::IfcTableRow; } +Type::Enum IfcTableRow::Class() { return Type::IfcTableRow; } +IfcTableRow::IfcTableRow(IfcAbstractEntityPtr e) { if (!is(Type::IfcTableRow)) throw; entity = e; } +// IfcTankType +IfcTankTypeEnum::IfcTankTypeEnum IfcTankType::PredefinedType() { return IfcTankTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcTankType::is(Type::Enum v) { return v == Type::IfcTankType || IfcFlowStorageDeviceType::is(v); } +Type::Enum IfcTankType::type() { return Type::IfcTankType; } +Type::Enum IfcTankType::Class() { return Type::IfcTankType; } +IfcTankType::IfcTankType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTankType)) throw; entity = e; } +// IfcTask +IfcIdentifier IfcTask::TaskId() { return *entity->getArgument(5); } +bool IfcTask::hasStatus() { return !entity->getArgument(6)->isNull(); } +IfcLabel IfcTask::Status() { return *entity->getArgument(6); } +bool IfcTask::hasWorkMethod() { return !entity->getArgument(7)->isNull(); } +IfcLabel IfcTask::WorkMethod() { return *entity->getArgument(7); } +bool IfcTask::IsMilestone() { return *entity->getArgument(8); } +bool IfcTask::hasPriority() { return !entity->getArgument(9)->isNull(); } +int IfcTask::Priority() { return *entity->getArgument(9); } +bool IfcTask::is(Type::Enum v) { return v == Type::IfcTask || IfcProcess::is(v); } +Type::Enum IfcTask::type() { return Type::IfcTask; } +Type::Enum IfcTask::Class() { return Type::IfcTask; } +IfcTask::IfcTask(IfcAbstractEntityPtr e) { if (!is(Type::IfcTask)) throw; entity = e; } +// IfcTelecomAddress +bool IfcTelecomAddress::hasTelephoneNumbers() { return !entity->getArgument(3)->isNull(); } +std::vector IfcTelecomAddress::TelephoneNumbers() { return *entity->getArgument(3); } +bool IfcTelecomAddress::hasFacsimileNumbers() { return !entity->getArgument(4)->isNull(); } +std::vector IfcTelecomAddress::FacsimileNumbers() { return *entity->getArgument(4); } +bool IfcTelecomAddress::hasPagerNumber() { return !entity->getArgument(5)->isNull(); } +IfcLabel IfcTelecomAddress::PagerNumber() { return *entity->getArgument(5); } +bool IfcTelecomAddress::hasElectronicMailAddresses() { return !entity->getArgument(6)->isNull(); } +std::vector IfcTelecomAddress::ElectronicMailAddresses() { return *entity->getArgument(6); } +bool IfcTelecomAddress::hasWWWHomePageURL() { return !entity->getArgument(7)->isNull(); } +IfcLabel IfcTelecomAddress::WWWHomePageURL() { return *entity->getArgument(7); } +bool IfcTelecomAddress::is(Type::Enum v) { return v == Type::IfcTelecomAddress || IfcAddress::is(v); } +Type::Enum IfcTelecomAddress::type() { return Type::IfcTelecomAddress; } +Type::Enum IfcTelecomAddress::Class() { return Type::IfcTelecomAddress; } +IfcTelecomAddress::IfcTelecomAddress(IfcAbstractEntityPtr e) { if (!is(Type::IfcTelecomAddress)) throw; entity = e; } +// IfcTendon +IfcTendonTypeEnum::IfcTendonTypeEnum IfcTendon::PredefinedType() { return IfcTendonTypeEnum::FromString(*entity->getArgument(9)); } +IfcPositiveLengthMeasure IfcTendon::NominalDiameter() { return *entity->getArgument(10); } +IfcAreaMeasure IfcTendon::CrossSectionArea() { return *entity->getArgument(11); } +bool IfcTendon::hasTensionForce() { return !entity->getArgument(12)->isNull(); } +IfcForceMeasure IfcTendon::TensionForce() { return *entity->getArgument(12); } +bool IfcTendon::hasPreStress() { return !entity->getArgument(13)->isNull(); } +IfcPressureMeasure IfcTendon::PreStress() { return *entity->getArgument(13); } +bool IfcTendon::hasFrictionCoefficient() { return !entity->getArgument(14)->isNull(); } +IfcNormalisedRatioMeasure IfcTendon::FrictionCoefficient() { return *entity->getArgument(14); } +bool IfcTendon::hasAnchorageSlip() { return !entity->getArgument(15)->isNull(); } +IfcPositiveLengthMeasure IfcTendon::AnchorageSlip() { return *entity->getArgument(15); } +bool IfcTendon::hasMinCurvatureRadius() { return !entity->getArgument(16)->isNull(); } +IfcPositiveLengthMeasure IfcTendon::MinCurvatureRadius() { return *entity->getArgument(16); } +bool IfcTendon::is(Type::Enum v) { return v == Type::IfcTendon || IfcReinforcingElement::is(v); } +Type::Enum IfcTendon::type() { return Type::IfcTendon; } +Type::Enum IfcTendon::Class() { return Type::IfcTendon; } +IfcTendon::IfcTendon(IfcAbstractEntityPtr e) { if (!is(Type::IfcTendon)) throw; entity = e; } +// IfcTendonAnchor +bool IfcTendonAnchor::is(Type::Enum v) { return v == Type::IfcTendonAnchor || IfcReinforcingElement::is(v); } +Type::Enum IfcTendonAnchor::type() { return Type::IfcTendonAnchor; } +Type::Enum IfcTendonAnchor::Class() { return Type::IfcTendonAnchor; } +IfcTendonAnchor::IfcTendonAnchor(IfcAbstractEntityPtr e) { if (!is(Type::IfcTendonAnchor)) throw; entity = e; } +// IfcTerminatorSymbol +SHARED_PTR IfcTerminatorSymbol::AnnotatedCurve() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +bool IfcTerminatorSymbol::is(Type::Enum v) { return v == Type::IfcTerminatorSymbol || IfcAnnotationSymbolOccurrence::is(v); } +Type::Enum IfcTerminatorSymbol::type() { return Type::IfcTerminatorSymbol; } +Type::Enum IfcTerminatorSymbol::Class() { return Type::IfcTerminatorSymbol; } +IfcTerminatorSymbol::IfcTerminatorSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcTerminatorSymbol)) throw; entity = e; } +// IfcTextLiteral +IfcPresentableText IfcTextLiteral::Literal() { return *entity->getArgument(0); } +IfcAxis2Placement IfcTextLiteral::Placement() { return *entity->getArgument(1); } +IfcTextPath::IfcTextPath IfcTextLiteral::Path() { return IfcTextPath::FromString(*entity->getArgument(2)); } +bool IfcTextLiteral::is(Type::Enum v) { return v == Type::IfcTextLiteral || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcTextLiteral::type() { return Type::IfcTextLiteral; } +Type::Enum IfcTextLiteral::Class() { return Type::IfcTextLiteral; } +IfcTextLiteral::IfcTextLiteral(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextLiteral)) throw; entity = e; } +// IfcTextLiteralWithExtent +SHARED_PTR IfcTextLiteralWithExtent::Extent() { return reinterpret_pointer_cast(*entity->getArgument(3)); } +IfcBoxAlignment IfcTextLiteralWithExtent::BoxAlignment() { return *entity->getArgument(4); } +bool IfcTextLiteralWithExtent::is(Type::Enum v) { return v == Type::IfcTextLiteralWithExtent || IfcTextLiteral::is(v); } +Type::Enum IfcTextLiteralWithExtent::type() { return Type::IfcTextLiteralWithExtent; } +Type::Enum IfcTextLiteralWithExtent::Class() { return Type::IfcTextLiteralWithExtent; } +IfcTextLiteralWithExtent::IfcTextLiteralWithExtent(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextLiteralWithExtent)) throw; entity = e; } +// IfcTextStyle +bool IfcTextStyle::hasTextCharacterAppearance() { return !entity->getArgument(1)->isNull(); } +IfcCharacterStyleSelect IfcTextStyle::TextCharacterAppearance() { return *entity->getArgument(1); } +bool IfcTextStyle::hasTextStyle() { return !entity->getArgument(2)->isNull(); } +IfcTextStyleSelect IfcTextStyle::TextStyle() { return *entity->getArgument(2); } +IfcTextFontSelect IfcTextStyle::TextFontStyle() { return *entity->getArgument(3); } +bool IfcTextStyle::is(Type::Enum v) { return v == Type::IfcTextStyle || IfcPresentationStyle::is(v); } +Type::Enum IfcTextStyle::type() { return Type::IfcTextStyle; } +Type::Enum IfcTextStyle::Class() { return Type::IfcTextStyle; } +IfcTextStyle::IfcTextStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyle)) throw; entity = e; } +// IfcTextStyleFontModel +bool IfcTextStyleFontModel::hasFontFamily() { return !entity->getArgument(1)->isNull(); } +std::vector IfcTextStyleFontModel::FontFamily() { return *entity->getArgument(1); } +bool IfcTextStyleFontModel::hasFontStyle() { return !entity->getArgument(2)->isNull(); } +IfcFontStyle IfcTextStyleFontModel::FontStyle() { return *entity->getArgument(2); } +bool IfcTextStyleFontModel::hasFontVariant() { return !entity->getArgument(3)->isNull(); } +IfcFontVariant IfcTextStyleFontModel::FontVariant() { return *entity->getArgument(3); } +bool IfcTextStyleFontModel::hasFontWeight() { return !entity->getArgument(4)->isNull(); } +IfcFontWeight IfcTextStyleFontModel::FontWeight() { return *entity->getArgument(4); } +IfcSizeSelect IfcTextStyleFontModel::FontSize() { return *entity->getArgument(5); } +bool IfcTextStyleFontModel::is(Type::Enum v) { return v == Type::IfcTextStyleFontModel || IfcPreDefinedTextFont::is(v); } +Type::Enum IfcTextStyleFontModel::type() { return Type::IfcTextStyleFontModel; } +Type::Enum IfcTextStyleFontModel::Class() { return Type::IfcTextStyleFontModel; } +IfcTextStyleFontModel::IfcTextStyleFontModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleFontModel)) throw; entity = e; } +// IfcTextStyleForDefinedFont +IfcColour IfcTextStyleForDefinedFont::Colour() { return *entity->getArgument(0); } +bool IfcTextStyleForDefinedFont::hasBackgroundColour() { return !entity->getArgument(1)->isNull(); } +IfcColour IfcTextStyleForDefinedFont::BackgroundColour() { return *entity->getArgument(1); } +bool IfcTextStyleForDefinedFont::is(Type::Enum v) { return v == Type::IfcTextStyleForDefinedFont; } +Type::Enum IfcTextStyleForDefinedFont::type() { return Type::IfcTextStyleForDefinedFont; } +Type::Enum IfcTextStyleForDefinedFont::Class() { return Type::IfcTextStyleForDefinedFont; } +IfcTextStyleForDefinedFont::IfcTextStyleForDefinedFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleForDefinedFont)) throw; entity = e; } +// IfcTextStyleTextModel +bool IfcTextStyleTextModel::hasTextIndent() { return !entity->getArgument(0)->isNull(); } +IfcSizeSelect IfcTextStyleTextModel::TextIndent() { return *entity->getArgument(0); } +bool IfcTextStyleTextModel::hasTextAlign() { return !entity->getArgument(1)->isNull(); } +IfcTextAlignment IfcTextStyleTextModel::TextAlign() { return *entity->getArgument(1); } +bool IfcTextStyleTextModel::hasTextDecoration() { return !entity->getArgument(2)->isNull(); } +IfcTextDecoration IfcTextStyleTextModel::TextDecoration() { return *entity->getArgument(2); } +bool IfcTextStyleTextModel::hasLetterSpacing() { return !entity->getArgument(3)->isNull(); } +IfcSizeSelect IfcTextStyleTextModel::LetterSpacing() { return *entity->getArgument(3); } +bool IfcTextStyleTextModel::hasWordSpacing() { return !entity->getArgument(4)->isNull(); } +IfcSizeSelect IfcTextStyleTextModel::WordSpacing() { return *entity->getArgument(4); } +bool IfcTextStyleTextModel::hasTextTransform() { return !entity->getArgument(5)->isNull(); } +IfcTextTransformation IfcTextStyleTextModel::TextTransform() { return *entity->getArgument(5); } +bool IfcTextStyleTextModel::hasLineHeight() { return !entity->getArgument(6)->isNull(); } +IfcSizeSelect IfcTextStyleTextModel::LineHeight() { return *entity->getArgument(6); } +bool IfcTextStyleTextModel::is(Type::Enum v) { return v == Type::IfcTextStyleTextModel; } +Type::Enum IfcTextStyleTextModel::type() { return Type::IfcTextStyleTextModel; } +Type::Enum IfcTextStyleTextModel::Class() { return Type::IfcTextStyleTextModel; } +IfcTextStyleTextModel::IfcTextStyleTextModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleTextModel)) throw; entity = e; } +// IfcTextStyleWithBoxCharacteristics +bool IfcTextStyleWithBoxCharacteristics::hasBoxHeight() { return !entity->getArgument(0)->isNull(); } +IfcPositiveLengthMeasure IfcTextStyleWithBoxCharacteristics::BoxHeight() { return *entity->getArgument(0); } +bool IfcTextStyleWithBoxCharacteristics::hasBoxWidth() { return !entity->getArgument(1)->isNull(); } +IfcPositiveLengthMeasure IfcTextStyleWithBoxCharacteristics::BoxWidth() { return *entity->getArgument(1); } +bool IfcTextStyleWithBoxCharacteristics::hasBoxSlantAngle() { return !entity->getArgument(2)->isNull(); } +IfcPlaneAngleMeasure IfcTextStyleWithBoxCharacteristics::BoxSlantAngle() { return *entity->getArgument(2); } +bool IfcTextStyleWithBoxCharacteristics::hasBoxRotateAngle() { return !entity->getArgument(3)->isNull(); } +IfcPlaneAngleMeasure IfcTextStyleWithBoxCharacteristics::BoxRotateAngle() { return *entity->getArgument(3); } +bool IfcTextStyleWithBoxCharacteristics::hasCharacterSpacing() { return !entity->getArgument(4)->isNull(); } +IfcSizeSelect IfcTextStyleWithBoxCharacteristics::CharacterSpacing() { return *entity->getArgument(4); } +bool IfcTextStyleWithBoxCharacteristics::is(Type::Enum v) { return v == Type::IfcTextStyleWithBoxCharacteristics; } +Type::Enum IfcTextStyleWithBoxCharacteristics::type() { return Type::IfcTextStyleWithBoxCharacteristics; } +Type::Enum IfcTextStyleWithBoxCharacteristics::Class() { return Type::IfcTextStyleWithBoxCharacteristics; } +IfcTextStyleWithBoxCharacteristics::IfcTextStyleWithBoxCharacteristics(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleWithBoxCharacteristics)) throw; entity = e; } +// IfcTextureCoordinate +IfcAnnotationSurface::list IfcTextureCoordinate::AnnotatedSurface() { RETURN_INVERSE(IfcAnnotationSurface) } +bool IfcTextureCoordinate::is(Type::Enum v) { return v == Type::IfcTextureCoordinate; } +Type::Enum IfcTextureCoordinate::type() { return Type::IfcTextureCoordinate; } +Type::Enum IfcTextureCoordinate::Class() { return Type::IfcTextureCoordinate; } +IfcTextureCoordinate::IfcTextureCoordinate(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureCoordinate)) throw; entity = e; } +// IfcTextureCoordinateGenerator +IfcLabel IfcTextureCoordinateGenerator::Mode() { return *entity->getArgument(0); } +SHARED_PTR< IfcTemplatedEntityList > IfcTextureCoordinateGenerator::Parameter() { RETURN_AS_LIST(IfcAbstractSelect,1) } +bool IfcTextureCoordinateGenerator::is(Type::Enum v) { return v == Type::IfcTextureCoordinateGenerator || IfcTextureCoordinate::is(v); } +Type::Enum IfcTextureCoordinateGenerator::type() { return Type::IfcTextureCoordinateGenerator; } +Type::Enum IfcTextureCoordinateGenerator::Class() { return Type::IfcTextureCoordinateGenerator; } +IfcTextureCoordinateGenerator::IfcTextureCoordinateGenerator(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureCoordinateGenerator)) throw; entity = e; } +// IfcTextureMap +SHARED_PTR< IfcTemplatedEntityList > IfcTextureMap::TextureMaps() { RETURN_AS_LIST(IfcVertexBasedTextureMap,0) } +bool IfcTextureMap::is(Type::Enum v) { return v == Type::IfcTextureMap || IfcTextureCoordinate::is(v); } +Type::Enum IfcTextureMap::type() { return Type::IfcTextureMap; } +Type::Enum IfcTextureMap::Class() { return Type::IfcTextureMap; } +IfcTextureMap::IfcTextureMap(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureMap)) throw; entity = e; } +// IfcTextureVertex +std::vector IfcTextureVertex::Coordinates() { return *entity->getArgument(0); } +bool IfcTextureVertex::is(Type::Enum v) { return v == Type::IfcTextureVertex; } +Type::Enum IfcTextureVertex::type() { return Type::IfcTextureVertex; } +Type::Enum IfcTextureVertex::Class() { return Type::IfcTextureVertex; } +IfcTextureVertex::IfcTextureVertex(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureVertex)) throw; entity = e; } +// IfcThermalMaterialProperties +bool IfcThermalMaterialProperties::hasSpecificHeatCapacity() { return !entity->getArgument(1)->isNull(); } +IfcSpecificHeatCapacityMeasure IfcThermalMaterialProperties::SpecificHeatCapacity() { return *entity->getArgument(1); } +bool IfcThermalMaterialProperties::hasBoilingPoint() { return !entity->getArgument(2)->isNull(); } +IfcThermodynamicTemperatureMeasure IfcThermalMaterialProperties::BoilingPoint() { return *entity->getArgument(2); } +bool IfcThermalMaterialProperties::hasFreezingPoint() { return !entity->getArgument(3)->isNull(); } +IfcThermodynamicTemperatureMeasure IfcThermalMaterialProperties::FreezingPoint() { return *entity->getArgument(3); } +bool IfcThermalMaterialProperties::hasThermalConductivity() { return !entity->getArgument(4)->isNull(); } +IfcThermalConductivityMeasure IfcThermalMaterialProperties::ThermalConductivity() { return *entity->getArgument(4); } +bool IfcThermalMaterialProperties::is(Type::Enum v) { return v == Type::IfcThermalMaterialProperties || IfcMaterialProperties::is(v); } +Type::Enum IfcThermalMaterialProperties::type() { return Type::IfcThermalMaterialProperties; } +Type::Enum IfcThermalMaterialProperties::Class() { return Type::IfcThermalMaterialProperties; } +IfcThermalMaterialProperties::IfcThermalMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcThermalMaterialProperties)) throw; entity = e; } +// IfcTimeSeries +IfcLabel IfcTimeSeries::Name() { return *entity->getArgument(0); } +bool IfcTimeSeries::hasDescription() { return !entity->getArgument(1)->isNull(); } +IfcText IfcTimeSeries::Description() { return *entity->getArgument(1); } +IfcDateTimeSelect IfcTimeSeries::StartTime() { return *entity->getArgument(2); } +IfcDateTimeSelect IfcTimeSeries::EndTime() { return *entity->getArgument(3); } +IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum IfcTimeSeries::TimeSeriesDataType() { return IfcTimeSeriesDataTypeEnum::FromString(*entity->getArgument(4)); } +IfcDataOriginEnum::IfcDataOriginEnum IfcTimeSeries::DataOrigin() { return IfcDataOriginEnum::FromString(*entity->getArgument(5)); } +bool IfcTimeSeries::hasUserDefinedDataOrigin() { return !entity->getArgument(6)->isNull(); } +IfcLabel IfcTimeSeries::UserDefinedDataOrigin() { return *entity->getArgument(6); } +bool IfcTimeSeries::hasUnit() { return !entity->getArgument(7)->isNull(); } +IfcUnit IfcTimeSeries::Unit() { return *entity->getArgument(7); } +IfcTimeSeriesReferenceRelationship::list IfcTimeSeries::DocumentedBy() { RETURN_INVERSE(IfcTimeSeriesReferenceRelationship) } +bool IfcTimeSeries::is(Type::Enum v) { return v == Type::IfcTimeSeries; } +Type::Enum IfcTimeSeries::type() { return Type::IfcTimeSeries; } +Type::Enum IfcTimeSeries::Class() { return Type::IfcTimeSeries; } +IfcTimeSeries::IfcTimeSeries(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeries)) throw; entity = e; } +// IfcTimeSeriesReferenceRelationship +SHARED_PTR IfcTimeSeriesReferenceRelationship::ReferencedTimeSeries() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR< IfcTemplatedEntityList > IfcTimeSeriesReferenceRelationship::TimeSeriesReferences() { RETURN_AS_LIST(IfcAbstractSelect,1) } +bool IfcTimeSeriesReferenceRelationship::is(Type::Enum v) { return v == Type::IfcTimeSeriesReferenceRelationship; } +Type::Enum IfcTimeSeriesReferenceRelationship::type() { return Type::IfcTimeSeriesReferenceRelationship; } +Type::Enum IfcTimeSeriesReferenceRelationship::Class() { return Type::IfcTimeSeriesReferenceRelationship; } +IfcTimeSeriesReferenceRelationship::IfcTimeSeriesReferenceRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeriesReferenceRelationship)) throw; entity = e; } +// IfcTimeSeriesSchedule +bool IfcTimeSeriesSchedule::hasApplicableDates() { return !entity->getArgument(5)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcTimeSeriesSchedule::ApplicableDates() { RETURN_AS_LIST(IfcAbstractSelect,5) } +IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum IfcTimeSeriesSchedule::TimeSeriesScheduleType() { return IfcTimeSeriesScheduleTypeEnum::FromString(*entity->getArgument(6)); } +SHARED_PTR IfcTimeSeriesSchedule::TimeSeries() { return reinterpret_pointer_cast(*entity->getArgument(7)); } +bool IfcTimeSeriesSchedule::is(Type::Enum v) { return v == Type::IfcTimeSeriesSchedule || IfcControl::is(v); } +Type::Enum IfcTimeSeriesSchedule::type() { return Type::IfcTimeSeriesSchedule; } +Type::Enum IfcTimeSeriesSchedule::Class() { return Type::IfcTimeSeriesSchedule; } +IfcTimeSeriesSchedule::IfcTimeSeriesSchedule(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeriesSchedule)) throw; entity = e; } +// IfcTimeSeriesValue +SHARED_PTR< IfcTemplatedEntityList > IfcTimeSeriesValue::ListValues() { RETURN_AS_LIST(IfcAbstractSelect,0) } +bool IfcTimeSeriesValue::is(Type::Enum v) { return v == Type::IfcTimeSeriesValue; } +Type::Enum IfcTimeSeriesValue::type() { return Type::IfcTimeSeriesValue; } +Type::Enum IfcTimeSeriesValue::Class() { return Type::IfcTimeSeriesValue; } +IfcTimeSeriesValue::IfcTimeSeriesValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeriesValue)) throw; entity = e; } +// IfcTopologicalRepresentationItem +bool IfcTopologicalRepresentationItem::is(Type::Enum v) { return v == Type::IfcTopologicalRepresentationItem || IfcRepresentationItem::is(v); } +Type::Enum IfcTopologicalRepresentationItem::type() { return Type::IfcTopologicalRepresentationItem; } +Type::Enum IfcTopologicalRepresentationItem::Class() { return Type::IfcTopologicalRepresentationItem; } +IfcTopologicalRepresentationItem::IfcTopologicalRepresentationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcTopologicalRepresentationItem)) throw; entity = e; } +// IfcTopologyRepresentation +bool IfcTopologyRepresentation::is(Type::Enum v) { return v == Type::IfcTopologyRepresentation || IfcShapeModel::is(v); } +Type::Enum IfcTopologyRepresentation::type() { return Type::IfcTopologyRepresentation; } +Type::Enum IfcTopologyRepresentation::Class() { return Type::IfcTopologyRepresentation; } +IfcTopologyRepresentation::IfcTopologyRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcTopologyRepresentation)) throw; entity = e; } +// IfcTransformerType +IfcTransformerTypeEnum::IfcTransformerTypeEnum IfcTransformerType::PredefinedType() { return IfcTransformerTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcTransformerType::is(Type::Enum v) { return v == Type::IfcTransformerType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcTransformerType::type() { return Type::IfcTransformerType; } +Type::Enum IfcTransformerType::Class() { return Type::IfcTransformerType; } +IfcTransformerType::IfcTransformerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTransformerType)) throw; entity = e; } +// IfcTransportElement +bool IfcTransportElement::hasOperationType() { return !entity->getArgument(8)->isNull(); } +IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElement::OperationType() { return IfcTransportElementTypeEnum::FromString(*entity->getArgument(8)); } +bool IfcTransportElement::hasCapacityByWeight() { return !entity->getArgument(9)->isNull(); } +IfcMassMeasure IfcTransportElement::CapacityByWeight() { return *entity->getArgument(9); } +bool IfcTransportElement::hasCapacityByNumber() { return !entity->getArgument(10)->isNull(); } +IfcCountMeasure IfcTransportElement::CapacityByNumber() { return *entity->getArgument(10); } +bool IfcTransportElement::is(Type::Enum v) { return v == Type::IfcTransportElement || IfcElement::is(v); } +Type::Enum IfcTransportElement::type() { return Type::IfcTransportElement; } +Type::Enum IfcTransportElement::Class() { return Type::IfcTransportElement; } +IfcTransportElement::IfcTransportElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcTransportElement)) throw; entity = e; } +// IfcTransportElementType +IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElementType::PredefinedType() { return IfcTransportElementTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcTransportElementType::is(Type::Enum v) { return v == Type::IfcTransportElementType || IfcElementType::is(v); } +Type::Enum IfcTransportElementType::type() { return Type::IfcTransportElementType; } +Type::Enum IfcTransportElementType::Class() { return Type::IfcTransportElementType; } +IfcTransportElementType::IfcTransportElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTransportElementType)) throw; entity = e; } +// IfcTrapeziumProfileDef +IfcPositiveLengthMeasure IfcTrapeziumProfileDef::BottomXDim() { return *entity->getArgument(3); } +IfcPositiveLengthMeasure IfcTrapeziumProfileDef::TopXDim() { return *entity->getArgument(4); } +IfcPositiveLengthMeasure IfcTrapeziumProfileDef::YDim() { return *entity->getArgument(5); } +IfcLengthMeasure IfcTrapeziumProfileDef::TopXOffset() { return *entity->getArgument(6); } +bool IfcTrapeziumProfileDef::is(Type::Enum v) { return v == Type::IfcTrapeziumProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcTrapeziumProfileDef::type() { return Type::IfcTrapeziumProfileDef; } +Type::Enum IfcTrapeziumProfileDef::Class() { return Type::IfcTrapeziumProfileDef; } +IfcTrapeziumProfileDef::IfcTrapeziumProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcTrapeziumProfileDef)) throw; entity = e; } +// IfcTrimmedCurve +SHARED_PTR IfcTrimmedCurve::BasisCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +SHARED_PTR< IfcTemplatedEntityList > IfcTrimmedCurve::Trim1() { RETURN_AS_LIST(IfcAbstractSelect,1) } +SHARED_PTR< IfcTemplatedEntityList > IfcTrimmedCurve::Trim2() { RETURN_AS_LIST(IfcAbstractSelect,2) } +bool IfcTrimmedCurve::SenseAgreement() { return *entity->getArgument(3); } +IfcTrimmingPreference::IfcTrimmingPreference IfcTrimmedCurve::MasterRepresentation() { return IfcTrimmingPreference::FromString(*entity->getArgument(4)); } +bool IfcTrimmedCurve::is(Type::Enum v) { return v == Type::IfcTrimmedCurve || IfcBoundedCurve::is(v); } +Type::Enum IfcTrimmedCurve::type() { return Type::IfcTrimmedCurve; } +Type::Enum IfcTrimmedCurve::Class() { return Type::IfcTrimmedCurve; } +IfcTrimmedCurve::IfcTrimmedCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcTrimmedCurve)) throw; entity = e; } +// IfcTubeBundleType +IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum IfcTubeBundleType::PredefinedType() { return IfcTubeBundleTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcTubeBundleType::is(Type::Enum v) { return v == Type::IfcTubeBundleType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcTubeBundleType::type() { return Type::IfcTubeBundleType; } +Type::Enum IfcTubeBundleType::Class() { return Type::IfcTubeBundleType; } +IfcTubeBundleType::IfcTubeBundleType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTubeBundleType)) throw; entity = e; } +// IfcTwoDirectionRepeatFactor +SHARED_PTR IfcTwoDirectionRepeatFactor::SecondRepeatFactor() { return reinterpret_pointer_cast(*entity->getArgument(1)); } +bool IfcTwoDirectionRepeatFactor::is(Type::Enum v) { return v == Type::IfcTwoDirectionRepeatFactor || IfcOneDirectionRepeatFactor::is(v); } +Type::Enum IfcTwoDirectionRepeatFactor::type() { return Type::IfcTwoDirectionRepeatFactor; } +Type::Enum IfcTwoDirectionRepeatFactor::Class() { return Type::IfcTwoDirectionRepeatFactor; } +IfcTwoDirectionRepeatFactor::IfcTwoDirectionRepeatFactor(IfcAbstractEntityPtr e) { if (!is(Type::IfcTwoDirectionRepeatFactor)) throw; entity = e; } +// IfcTypeObject +bool IfcTypeObject::hasApplicableOccurrence() { return !entity->getArgument(4)->isNull(); } +IfcLabel IfcTypeObject::ApplicableOccurrence() { return *entity->getArgument(4); } +bool IfcTypeObject::hasHasPropertySets() { return !entity->getArgument(5)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcTypeObject::HasPropertySets() { RETURN_AS_LIST(IfcPropertySetDefinition,5) } +IfcRelDefinesByType::list IfcTypeObject::ObjectTypeOf() { RETURN_INVERSE(IfcRelDefinesByType) } +bool IfcTypeObject::is(Type::Enum v) { return v == Type::IfcTypeObject || IfcObjectDefinition::is(v); } +Type::Enum IfcTypeObject::type() { return Type::IfcTypeObject; } +Type::Enum IfcTypeObject::Class() { return Type::IfcTypeObject; } +IfcTypeObject::IfcTypeObject(IfcAbstractEntityPtr e) { if (!is(Type::IfcTypeObject)) throw; entity = e; } +// IfcTypeProduct +bool IfcTypeProduct::hasRepresentationMaps() { return !entity->getArgument(6)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcTypeProduct::RepresentationMaps() { RETURN_AS_LIST(IfcRepresentationMap,6) } +bool IfcTypeProduct::hasTag() { return !entity->getArgument(7)->isNull(); } +IfcLabel IfcTypeProduct::Tag() { return *entity->getArgument(7); } +bool IfcTypeProduct::is(Type::Enum v) { return v == Type::IfcTypeProduct || IfcTypeObject::is(v); } +Type::Enum IfcTypeProduct::type() { return Type::IfcTypeProduct; } +Type::Enum IfcTypeProduct::Class() { return Type::IfcTypeProduct; } +IfcTypeProduct::IfcTypeProduct(IfcAbstractEntityPtr e) { if (!is(Type::IfcTypeProduct)) throw; entity = e; } +// IfcUShapeProfileDef +IfcPositiveLengthMeasure IfcUShapeProfileDef::Depth() { return *entity->getArgument(3); } +IfcPositiveLengthMeasure IfcUShapeProfileDef::FlangeWidth() { return *entity->getArgument(4); } +IfcPositiveLengthMeasure IfcUShapeProfileDef::WebThickness() { return *entity->getArgument(5); } +IfcPositiveLengthMeasure IfcUShapeProfileDef::FlangeThickness() { return *entity->getArgument(6); } +bool IfcUShapeProfileDef::hasFilletRadius() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcUShapeProfileDef::FilletRadius() { return *entity->getArgument(7); } +bool IfcUShapeProfileDef::hasEdgeRadius() { return !entity->getArgument(8)->isNull(); } +IfcPositiveLengthMeasure IfcUShapeProfileDef::EdgeRadius() { return *entity->getArgument(8); } +bool IfcUShapeProfileDef::hasFlangeSlope() { return !entity->getArgument(9)->isNull(); } +IfcPlaneAngleMeasure IfcUShapeProfileDef::FlangeSlope() { return *entity->getArgument(9); } +bool IfcUShapeProfileDef::hasCentreOfGravityInX() { return !entity->getArgument(10)->isNull(); } +IfcPositiveLengthMeasure IfcUShapeProfileDef::CentreOfGravityInX() { return *entity->getArgument(10); } +bool IfcUShapeProfileDef::is(Type::Enum v) { return v == Type::IfcUShapeProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcUShapeProfileDef::type() { return Type::IfcUShapeProfileDef; } +Type::Enum IfcUShapeProfileDef::Class() { return Type::IfcUShapeProfileDef; } +IfcUShapeProfileDef::IfcUShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcUShapeProfileDef)) throw; entity = e; } +// IfcUnitAssignment +SHARED_PTR< IfcTemplatedEntityList > IfcUnitAssignment::Units() { RETURN_AS_LIST(IfcAbstractSelect,0) } +bool IfcUnitAssignment::is(Type::Enum v) { return v == Type::IfcUnitAssignment; } +Type::Enum IfcUnitAssignment::type() { return Type::IfcUnitAssignment; } +Type::Enum IfcUnitAssignment::Class() { return Type::IfcUnitAssignment; } +IfcUnitAssignment::IfcUnitAssignment(IfcAbstractEntityPtr e) { if (!is(Type::IfcUnitAssignment)) throw; entity = e; } +// IfcUnitaryEquipmentType +IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum IfcUnitaryEquipmentType::PredefinedType() { return IfcUnitaryEquipmentTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcUnitaryEquipmentType::is(Type::Enum v) { return v == Type::IfcUnitaryEquipmentType || IfcEnergyConversionDeviceType::is(v); } +Type::Enum IfcUnitaryEquipmentType::type() { return Type::IfcUnitaryEquipmentType; } +Type::Enum IfcUnitaryEquipmentType::Class() { return Type::IfcUnitaryEquipmentType; } +IfcUnitaryEquipmentType::IfcUnitaryEquipmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcUnitaryEquipmentType)) throw; entity = e; } +// IfcValveType +IfcValveTypeEnum::IfcValveTypeEnum IfcValveType::PredefinedType() { return IfcValveTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcValveType::is(Type::Enum v) { return v == Type::IfcValveType || IfcFlowControllerType::is(v); } +Type::Enum IfcValveType::type() { return Type::IfcValveType; } +Type::Enum IfcValveType::Class() { return Type::IfcValveType; } +IfcValveType::IfcValveType(IfcAbstractEntityPtr e) { if (!is(Type::IfcValveType)) throw; entity = e; } +// IfcVector +SHARED_PTR IfcVector::Orientation() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +IfcLengthMeasure IfcVector::Magnitude() { return *entity->getArgument(1); } +bool IfcVector::is(Type::Enum v) { return v == Type::IfcVector || IfcGeometricRepresentationItem::is(v); } +Type::Enum IfcVector::type() { return Type::IfcVector; } +Type::Enum IfcVector::Class() { return Type::IfcVector; } +IfcVector::IfcVector(IfcAbstractEntityPtr e) { if (!is(Type::IfcVector)) throw; entity = e; } +// IfcVertex +bool IfcVertex::is(Type::Enum v) { return v == Type::IfcVertex || IfcTopologicalRepresentationItem::is(v); } +Type::Enum IfcVertex::type() { return Type::IfcVertex; } +Type::Enum IfcVertex::Class() { return Type::IfcVertex; } +IfcVertex::IfcVertex(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertex)) throw; entity = e; } +// IfcVertexBasedTextureMap +SHARED_PTR< IfcTemplatedEntityList > IfcVertexBasedTextureMap::TextureVertices() { RETURN_AS_LIST(IfcTextureVertex,0) } +SHARED_PTR< IfcTemplatedEntityList > IfcVertexBasedTextureMap::TexturePoints() { RETURN_AS_LIST(IfcCartesianPoint,1) } +bool IfcVertexBasedTextureMap::is(Type::Enum v) { return v == Type::IfcVertexBasedTextureMap; } +Type::Enum IfcVertexBasedTextureMap::type() { return Type::IfcVertexBasedTextureMap; } +Type::Enum IfcVertexBasedTextureMap::Class() { return Type::IfcVertexBasedTextureMap; } +IfcVertexBasedTextureMap::IfcVertexBasedTextureMap(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertexBasedTextureMap)) throw; entity = e; } +// IfcVertexLoop +SHARED_PTR IfcVertexLoop::LoopVertex() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcVertexLoop::is(Type::Enum v) { return v == Type::IfcVertexLoop || IfcLoop::is(v); } +Type::Enum IfcVertexLoop::type() { return Type::IfcVertexLoop; } +Type::Enum IfcVertexLoop::Class() { return Type::IfcVertexLoop; } +IfcVertexLoop::IfcVertexLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertexLoop)) throw; entity = e; } +// IfcVertexPoint +SHARED_PTR IfcVertexPoint::VertexGeometry() { return reinterpret_pointer_cast(*entity->getArgument(0)); } +bool IfcVertexPoint::is(Type::Enum v) { return v == Type::IfcVertexPoint || IfcVertex::is(v); } +Type::Enum IfcVertexPoint::type() { return Type::IfcVertexPoint; } +Type::Enum IfcVertexPoint::Class() { return Type::IfcVertexPoint; } +IfcVertexPoint::IfcVertexPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertexPoint)) throw; entity = e; } +// IfcVibrationIsolatorType +IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum IfcVibrationIsolatorType::PredefinedType() { return IfcVibrationIsolatorTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcVibrationIsolatorType::is(Type::Enum v) { return v == Type::IfcVibrationIsolatorType || IfcDiscreteAccessoryType::is(v); } +Type::Enum IfcVibrationIsolatorType::type() { return Type::IfcVibrationIsolatorType; } +Type::Enum IfcVibrationIsolatorType::Class() { return Type::IfcVibrationIsolatorType; } +IfcVibrationIsolatorType::IfcVibrationIsolatorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcVibrationIsolatorType)) throw; entity = e; } +// IfcVirtualElement +bool IfcVirtualElement::is(Type::Enum v) { return v == Type::IfcVirtualElement || IfcElement::is(v); } +Type::Enum IfcVirtualElement::type() { return Type::IfcVirtualElement; } +Type::Enum IfcVirtualElement::Class() { return Type::IfcVirtualElement; } +IfcVirtualElement::IfcVirtualElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcVirtualElement)) throw; entity = e; } +// IfcVirtualGridIntersection +SHARED_PTR< IfcTemplatedEntityList > IfcVirtualGridIntersection::IntersectingAxes() { RETURN_AS_LIST(IfcGridAxis,0) } +std::vector IfcVirtualGridIntersection::OffsetDistances() { return *entity->getArgument(1); } +bool IfcVirtualGridIntersection::is(Type::Enum v) { return v == Type::IfcVirtualGridIntersection; } +Type::Enum IfcVirtualGridIntersection::type() { return Type::IfcVirtualGridIntersection; } +Type::Enum IfcVirtualGridIntersection::Class() { return Type::IfcVirtualGridIntersection; } +IfcVirtualGridIntersection::IfcVirtualGridIntersection(IfcAbstractEntityPtr e) { if (!is(Type::IfcVirtualGridIntersection)) throw; entity = e; } +// IfcWall +bool IfcWall::is(Type::Enum v) { return v == Type::IfcWall || IfcBuildingElement::is(v); } +Type::Enum IfcWall::type() { return Type::IfcWall; } +Type::Enum IfcWall::Class() { return Type::IfcWall; } +IfcWall::IfcWall(IfcAbstractEntityPtr e) { if (!is(Type::IfcWall)) throw; entity = e; } +// IfcWallStandardCase +bool IfcWallStandardCase::is(Type::Enum v) { return v == Type::IfcWallStandardCase || IfcWall::is(v); } +Type::Enum IfcWallStandardCase::type() { return Type::IfcWallStandardCase; } +Type::Enum IfcWallStandardCase::Class() { return Type::IfcWallStandardCase; } +IfcWallStandardCase::IfcWallStandardCase(IfcAbstractEntityPtr e) { if (!is(Type::IfcWallStandardCase)) throw; entity = e; } +// IfcWallType +IfcWallTypeEnum::IfcWallTypeEnum IfcWallType::PredefinedType() { return IfcWallTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcWallType::is(Type::Enum v) { return v == Type::IfcWallType || IfcBuildingElementType::is(v); } +Type::Enum IfcWallType::type() { return Type::IfcWallType; } +Type::Enum IfcWallType::Class() { return Type::IfcWallType; } +IfcWallType::IfcWallType(IfcAbstractEntityPtr e) { if (!is(Type::IfcWallType)) throw; entity = e; } +// IfcWasteTerminalType +IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum IfcWasteTerminalType::PredefinedType() { return IfcWasteTerminalTypeEnum::FromString(*entity->getArgument(9)); } +bool IfcWasteTerminalType::is(Type::Enum v) { return v == Type::IfcWasteTerminalType || IfcFlowTerminalType::is(v); } +Type::Enum IfcWasteTerminalType::type() { return Type::IfcWasteTerminalType; } +Type::Enum IfcWasteTerminalType::Class() { return Type::IfcWasteTerminalType; } +IfcWasteTerminalType::IfcWasteTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcWasteTerminalType)) throw; entity = e; } +// IfcWaterProperties +bool IfcWaterProperties::hasIsPotable() { return !entity->getArgument(1)->isNull(); } +bool IfcWaterProperties::IsPotable() { return *entity->getArgument(1); } +bool IfcWaterProperties::hasHardness() { return !entity->getArgument(2)->isNull(); } +IfcIonConcentrationMeasure IfcWaterProperties::Hardness() { return *entity->getArgument(2); } +bool IfcWaterProperties::hasAlkalinityConcentration() { return !entity->getArgument(3)->isNull(); } +IfcIonConcentrationMeasure IfcWaterProperties::AlkalinityConcentration() { return *entity->getArgument(3); } +bool IfcWaterProperties::hasAcidityConcentration() { return !entity->getArgument(4)->isNull(); } +IfcIonConcentrationMeasure IfcWaterProperties::AcidityConcentration() { return *entity->getArgument(4); } +bool IfcWaterProperties::hasImpuritiesContent() { return !entity->getArgument(5)->isNull(); } +IfcNormalisedRatioMeasure IfcWaterProperties::ImpuritiesContent() { return *entity->getArgument(5); } +bool IfcWaterProperties::hasPHLevel() { return !entity->getArgument(6)->isNull(); } +IfcPHMeasure IfcWaterProperties::PHLevel() { return *entity->getArgument(6); } +bool IfcWaterProperties::hasDissolvedSolidsContent() { return !entity->getArgument(7)->isNull(); } +IfcNormalisedRatioMeasure IfcWaterProperties::DissolvedSolidsContent() { return *entity->getArgument(7); } +bool IfcWaterProperties::is(Type::Enum v) { return v == Type::IfcWaterProperties || IfcMaterialProperties::is(v); } +Type::Enum IfcWaterProperties::type() { return Type::IfcWaterProperties; } +Type::Enum IfcWaterProperties::Class() { return Type::IfcWaterProperties; } +IfcWaterProperties::IfcWaterProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcWaterProperties)) throw; entity = e; } +// IfcWindow +bool IfcWindow::hasOverallHeight() { return !entity->getArgument(8)->isNull(); } +IfcPositiveLengthMeasure IfcWindow::OverallHeight() { return *entity->getArgument(8); } +bool IfcWindow::hasOverallWidth() { return !entity->getArgument(9)->isNull(); } +IfcPositiveLengthMeasure IfcWindow::OverallWidth() { return *entity->getArgument(9); } +bool IfcWindow::is(Type::Enum v) { return v == Type::IfcWindow || IfcBuildingElement::is(v); } +Type::Enum IfcWindow::type() { return Type::IfcWindow; } +Type::Enum IfcWindow::Class() { return Type::IfcWindow; } +IfcWindow::IfcWindow(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindow)) throw; entity = e; } +// IfcWindowLiningProperties +bool IfcWindowLiningProperties::hasLiningDepth() { return !entity->getArgument(4)->isNull(); } +IfcPositiveLengthMeasure IfcWindowLiningProperties::LiningDepth() { return *entity->getArgument(4); } +bool IfcWindowLiningProperties::hasLiningThickness() { return !entity->getArgument(5)->isNull(); } +IfcPositiveLengthMeasure IfcWindowLiningProperties::LiningThickness() { return *entity->getArgument(5); } +bool IfcWindowLiningProperties::hasTransomThickness() { return !entity->getArgument(6)->isNull(); } +IfcPositiveLengthMeasure IfcWindowLiningProperties::TransomThickness() { return *entity->getArgument(6); } +bool IfcWindowLiningProperties::hasMullionThickness() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcWindowLiningProperties::MullionThickness() { return *entity->getArgument(7); } +bool IfcWindowLiningProperties::hasFirstTransomOffset() { return !entity->getArgument(8)->isNull(); } +IfcNormalisedRatioMeasure IfcWindowLiningProperties::FirstTransomOffset() { return *entity->getArgument(8); } +bool IfcWindowLiningProperties::hasSecondTransomOffset() { return !entity->getArgument(9)->isNull(); } +IfcNormalisedRatioMeasure IfcWindowLiningProperties::SecondTransomOffset() { return *entity->getArgument(9); } +bool IfcWindowLiningProperties::hasFirstMullionOffset() { return !entity->getArgument(10)->isNull(); } +IfcNormalisedRatioMeasure IfcWindowLiningProperties::FirstMullionOffset() { return *entity->getArgument(10); } +bool IfcWindowLiningProperties::hasSecondMullionOffset() { return !entity->getArgument(11)->isNull(); } +IfcNormalisedRatioMeasure IfcWindowLiningProperties::SecondMullionOffset() { return *entity->getArgument(11); } +bool IfcWindowLiningProperties::hasShapeAspectStyle() { return !entity->getArgument(12)->isNull(); } +SHARED_PTR IfcWindowLiningProperties::ShapeAspectStyle() { return reinterpret_pointer_cast(*entity->getArgument(12)); } +bool IfcWindowLiningProperties::is(Type::Enum v) { return v == Type::IfcWindowLiningProperties || IfcPropertySetDefinition::is(v); } +Type::Enum IfcWindowLiningProperties::type() { return Type::IfcWindowLiningProperties; } +Type::Enum IfcWindowLiningProperties::Class() { return Type::IfcWindowLiningProperties; } +IfcWindowLiningProperties::IfcWindowLiningProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindowLiningProperties)) throw; entity = e; } +// IfcWindowPanelProperties +IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum IfcWindowPanelProperties::OperationType() { return IfcWindowPanelOperationEnum::FromString(*entity->getArgument(4)); } +IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum IfcWindowPanelProperties::PanelPosition() { return IfcWindowPanelPositionEnum::FromString(*entity->getArgument(5)); } +bool IfcWindowPanelProperties::hasFrameDepth() { return !entity->getArgument(6)->isNull(); } +IfcPositiveLengthMeasure IfcWindowPanelProperties::FrameDepth() { return *entity->getArgument(6); } +bool IfcWindowPanelProperties::hasFrameThickness() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcWindowPanelProperties::FrameThickness() { return *entity->getArgument(7); } +bool IfcWindowPanelProperties::hasShapeAspectStyle() { return !entity->getArgument(8)->isNull(); } +SHARED_PTR IfcWindowPanelProperties::ShapeAspectStyle() { return reinterpret_pointer_cast(*entity->getArgument(8)); } +bool IfcWindowPanelProperties::is(Type::Enum v) { return v == Type::IfcWindowPanelProperties || IfcPropertySetDefinition::is(v); } +Type::Enum IfcWindowPanelProperties::type() { return Type::IfcWindowPanelProperties; } +Type::Enum IfcWindowPanelProperties::Class() { return Type::IfcWindowPanelProperties; } +IfcWindowPanelProperties::IfcWindowPanelProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindowPanelProperties)) throw; entity = e; } +// IfcWindowStyle +IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum IfcWindowStyle::ConstructionType() { return IfcWindowStyleConstructionEnum::FromString(*entity->getArgument(8)); } +IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum IfcWindowStyle::OperationType() { return IfcWindowStyleOperationEnum::FromString(*entity->getArgument(9)); } +bool IfcWindowStyle::ParameterTakesPrecedence() { return *entity->getArgument(10); } +bool IfcWindowStyle::Sizeable() { return *entity->getArgument(11); } +bool IfcWindowStyle::is(Type::Enum v) { return v == Type::IfcWindowStyle || IfcTypeProduct::is(v); } +Type::Enum IfcWindowStyle::type() { return Type::IfcWindowStyle; } +Type::Enum IfcWindowStyle::Class() { return Type::IfcWindowStyle; } +IfcWindowStyle::IfcWindowStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindowStyle)) throw; entity = e; } +// IfcWorkControl +IfcIdentifier IfcWorkControl::Identifier() { return *entity->getArgument(5); } +IfcDateTimeSelect IfcWorkControl::CreationDate() { return *entity->getArgument(6); } +bool IfcWorkControl::hasCreators() { return !entity->getArgument(7)->isNull(); } +SHARED_PTR< IfcTemplatedEntityList > IfcWorkControl::Creators() { RETURN_AS_LIST(IfcPerson,7) } +bool IfcWorkControl::hasPurpose() { return !entity->getArgument(8)->isNull(); } +IfcLabel IfcWorkControl::Purpose() { return *entity->getArgument(8); } +bool IfcWorkControl::hasDuration() { return !entity->getArgument(9)->isNull(); } +IfcTimeMeasure IfcWorkControl::Duration() { return *entity->getArgument(9); } +bool IfcWorkControl::hasTotalFloat() { return !entity->getArgument(10)->isNull(); } +IfcTimeMeasure IfcWorkControl::TotalFloat() { return *entity->getArgument(10); } +IfcDateTimeSelect IfcWorkControl::StartTime() { return *entity->getArgument(11); } +bool IfcWorkControl::hasFinishTime() { return !entity->getArgument(12)->isNull(); } +IfcDateTimeSelect IfcWorkControl::FinishTime() { return *entity->getArgument(12); } +bool IfcWorkControl::hasWorkControlType() { return !entity->getArgument(13)->isNull(); } +IfcWorkControlTypeEnum::IfcWorkControlTypeEnum IfcWorkControl::WorkControlType() { return IfcWorkControlTypeEnum::FromString(*entity->getArgument(13)); } +bool IfcWorkControl::hasUserDefinedControlType() { return !entity->getArgument(14)->isNull(); } +IfcLabel IfcWorkControl::UserDefinedControlType() { return *entity->getArgument(14); } +bool IfcWorkControl::is(Type::Enum v) { return v == Type::IfcWorkControl || IfcControl::is(v); } +Type::Enum IfcWorkControl::type() { return Type::IfcWorkControl; } +Type::Enum IfcWorkControl::Class() { return Type::IfcWorkControl; } +IfcWorkControl::IfcWorkControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcWorkControl)) throw; entity = e; } +// IfcWorkPlan +bool IfcWorkPlan::is(Type::Enum v) { return v == Type::IfcWorkPlan || IfcWorkControl::is(v); } +Type::Enum IfcWorkPlan::type() { return Type::IfcWorkPlan; } +Type::Enum IfcWorkPlan::Class() { return Type::IfcWorkPlan; } +IfcWorkPlan::IfcWorkPlan(IfcAbstractEntityPtr e) { if (!is(Type::IfcWorkPlan)) throw; entity = e; } +// IfcWorkSchedule +bool IfcWorkSchedule::is(Type::Enum v) { return v == Type::IfcWorkSchedule || IfcWorkControl::is(v); } +Type::Enum IfcWorkSchedule::type() { return Type::IfcWorkSchedule; } +Type::Enum IfcWorkSchedule::Class() { return Type::IfcWorkSchedule; } +IfcWorkSchedule::IfcWorkSchedule(IfcAbstractEntityPtr e) { if (!is(Type::IfcWorkSchedule)) throw; entity = e; } +// IfcZShapeProfileDef +IfcPositiveLengthMeasure IfcZShapeProfileDef::Depth() { return *entity->getArgument(3); } +IfcPositiveLengthMeasure IfcZShapeProfileDef::FlangeWidth() { return *entity->getArgument(4); } +IfcPositiveLengthMeasure IfcZShapeProfileDef::WebThickness() { return *entity->getArgument(5); } +IfcPositiveLengthMeasure IfcZShapeProfileDef::FlangeThickness() { return *entity->getArgument(6); } +bool IfcZShapeProfileDef::hasFilletRadius() { return !entity->getArgument(7)->isNull(); } +IfcPositiveLengthMeasure IfcZShapeProfileDef::FilletRadius() { return *entity->getArgument(7); } +bool IfcZShapeProfileDef::hasEdgeRadius() { return !entity->getArgument(8)->isNull(); } +IfcPositiveLengthMeasure IfcZShapeProfileDef::EdgeRadius() { return *entity->getArgument(8); } +bool IfcZShapeProfileDef::is(Type::Enum v) { return v == Type::IfcZShapeProfileDef || IfcParameterizedProfileDef::is(v); } +Type::Enum IfcZShapeProfileDef::type() { return Type::IfcZShapeProfileDef; } +Type::Enum IfcZShapeProfileDef::Class() { return Type::IfcZShapeProfileDef; } +IfcZShapeProfileDef::IfcZShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcZShapeProfileDef)) throw; entity = e; } +// IfcZone +bool IfcZone::is(Type::Enum v) { return v == Type::IfcZone || IfcGroup::is(v); } +Type::Enum IfcZone::type() { return Type::IfcZone; } +Type::Enum IfcZone::Class() { return Type::IfcZone; } +IfcZone::IfcZone(IfcAbstractEntityPtr e) { if (!is(Type::IfcZone)) throw; entity = e; } diff --git a/src/ifcparse/Ifc2x3.h b/src/ifcparse/Ifc2x3.h new file mode 100644 index 0000000000..fed67cdeb7 --- /dev/null +++ b/src/ifcparse/Ifc2x3.h @@ -0,0 +1,9289 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +/******************************************************************************** + * * + * This file has been generated from IFC2X3_TC1.exp. Do not make modifications * + * but instead modify the python script that has been used to generate this. * + * * + ********************************************************************************/ + +#ifndef IFC2X3_H +#define IFC2X3_H + +#pragma once + +#include +#include + +#include "../ifcparse/IfcUtil.h" +#include "../ifcparse/Ifc2x3enum.h" + +using namespace IfcUtil; + +#define RETURN_INVERSE(T) \ + IfcEntities e = entity->getInverse(T::Class()); \ + SHARED_PTR< IfcTemplatedEntityList > l ( new IfcTemplatedEntityList() ); \ + for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) { \ + l->push(reinterpret_pointer_cast(*it));\ + } \ + return l; + +#define RETURN_AS_SINGLE(T,a) \ + return reinterpret_pointer_cast(*entity->getArgument(a)); + +#define RETURN_AS_LIST(T,a) \ + IfcEntities e = *entity->getArgument(a); \ + SHARED_PTR< IfcTemplatedEntityList > l ( new IfcTemplatedEntityList() ); \ + for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) { \ + l->push(reinterpret_pointer_cast(*it)); \ + } \ + return l; + +namespace Ifc2x3 { + +typedef float IfcAbsorbedDoseMeasure; +typedef float IfcAccelerationMeasure; +typedef float IfcAmountOfSubstanceMeasure; +typedef float IfcAngularVelocityMeasure; +typedef float IfcAreaMeasure; +typedef bool IfcBoolean; +typedef std::vector /*[1:2]*/ IfcComplexNumber; +typedef std::vector /*[3:4]*/ IfcCompoundPlaneAngleMeasure; +typedef float IfcContextDependentMeasure; +typedef float IfcCountMeasure; +typedef float IfcCurvatureMeasure; +typedef int IfcDayInMonthNumber; +typedef int IfcDaylightSavingHour; +typedef std::string IfcDescriptiveMeasure; +typedef int IfcDimensionCount; +typedef float IfcDoseEquivalentMeasure; +typedef float IfcDynamicViscosityMeasure; +typedef float IfcElectricCapacitanceMeasure; +typedef float IfcElectricChargeMeasure; +typedef float IfcElectricConductanceMeasure; +typedef float IfcElectricCurrentMeasure; +typedef float IfcElectricResistanceMeasure; +typedef float IfcElectricVoltageMeasure; +typedef float IfcEnergyMeasure; +typedef std::string IfcFontStyle; +typedef std::string IfcFontVariant; +typedef std::string IfcFontWeight; +typedef float IfcForceMeasure; +typedef float IfcFrequencyMeasure; +typedef std::string IfcGloballyUniqueId; +typedef float IfcHeatFluxDensityMeasure; +typedef float IfcHeatingValueMeasure; +typedef int IfcHourInDay; +typedef std::string IfcIdentifier; +typedef float IfcIlluminanceMeasure; +typedef float IfcInductanceMeasure; +typedef int IfcInteger; +typedef int IfcIntegerCountRateMeasure; +typedef float IfcIonConcentrationMeasure; +typedef float IfcIsothermalMoistureCapacityMeasure; +typedef float IfcKinematicViscosityMeasure; +typedef std::string IfcLabel; +typedef float IfcLengthMeasure; +typedef float IfcLinearForceMeasure; +typedef float IfcLinearMomentMeasure; +typedef float IfcLinearStiffnessMeasure; +typedef float IfcLinearVelocityMeasure; +typedef bool IfcLogical; +typedef float IfcLuminousFluxMeasure; +typedef float IfcLuminousIntensityDistributionMeasure; +typedef float IfcLuminousIntensityMeasure; +typedef float IfcMagneticFluxDensityMeasure; +typedef float IfcMagneticFluxMeasure; +typedef float IfcMassDensityMeasure; +typedef float IfcMassFlowRateMeasure; +typedef float IfcMassMeasure; +typedef float IfcMassPerLengthMeasure; +typedef int IfcMinuteInHour; +typedef float IfcModulusOfElasticityMeasure; +typedef float IfcModulusOfLinearSubgradeReactionMeasure; +typedef float IfcModulusOfRotationalSubgradeReactionMeasure; +typedef float IfcModulusOfSubgradeReactionMeasure; +typedef float IfcMoistureDiffusivityMeasure; +typedef float IfcMolecularWeightMeasure; +typedef float IfcMomentOfInertiaMeasure; +typedef float IfcMonetaryMeasure; +typedef int IfcMonthInYearNumber; +typedef float IfcNumericMeasure; +typedef float IfcPHMeasure; +typedef float IfcParameterValue; +typedef float IfcPlanarForceMeasure; +typedef float IfcPlaneAngleMeasure; +typedef float IfcPowerMeasure; +typedef std::string IfcPresentableText; +typedef float IfcPressureMeasure; +typedef float IfcRadioActivityMeasure; +typedef float IfcRatioMeasure; +typedef float IfcReal; +typedef float IfcRotationalFrequencyMeasure; +typedef float IfcRotationalMassMeasure; +typedef float IfcRotationalStiffnessMeasure; +typedef float IfcSecondInMinute; +typedef float IfcSectionModulusMeasure; +typedef float IfcSectionalAreaIntegralMeasure; +typedef float IfcShearModulusMeasure; +typedef float IfcSolidAngleMeasure; +typedef float IfcSoundPowerMeasure; +typedef float IfcSoundPressureMeasure; +typedef float IfcSpecificHeatCapacityMeasure; +typedef float IfcSpecularExponent; +typedef float IfcSpecularRoughness; +typedef float IfcTemperatureGradientMeasure; +typedef std::string IfcText; +typedef std::string IfcTextAlignment; +typedef std::string IfcTextDecoration; +typedef std::string IfcTextFontName; +typedef std::string IfcTextTransformation; +typedef float IfcThermalAdmittanceMeasure; +typedef float IfcThermalConductivityMeasure; +typedef float IfcThermalExpansionCoefficientMeasure; +typedef float IfcThermalResistanceMeasure; +typedef float IfcThermalTransmittanceMeasure; +typedef float IfcThermodynamicTemperatureMeasure; +typedef float IfcTimeMeasure; +typedef int IfcTimeStamp; +typedef float IfcTorqueMeasure; +typedef float IfcVaporPermeabilityMeasure; +typedef float IfcVolumeMeasure; +typedef float IfcVolumetricFlowRateMeasure; +typedef float IfcWarpingConstantMeasure; +typedef float IfcWarpingMomentMeasure; +typedef int IfcYearNumber; +typedef SHARED_PTR IfcActorSelect; +typedef SHARED_PTR IfcAppliedValueSelect; +typedef SHARED_PTR IfcAxis2Placement; +typedef SHARED_PTR IfcBooleanOperand; +typedef SHARED_PTR IfcCharacterStyleSelect; +typedef SHARED_PTR IfcClassificationNotationSelect; +typedef SHARED_PTR IfcColour; +typedef SHARED_PTR IfcColourOrFactor; +typedef SHARED_PTR IfcConditionCriterionSelect; +typedef SHARED_PTR IfcCsgSelect; +typedef SHARED_PTR IfcCurveFontOrScaledCurveFontSelect; +typedef SHARED_PTR IfcCurveOrEdgeCurve; +typedef SHARED_PTR IfcCurveStyleFontSelect; +typedef SHARED_PTR IfcDateTimeSelect; +typedef SHARED_PTR IfcDefinedSymbolSelect; +typedef SHARED_PTR IfcDerivedMeasureValue; +typedef SHARED_PTR IfcDocumentSelect; +typedef SHARED_PTR IfcDraughtingCalloutElement; +typedef SHARED_PTR IfcFillAreaStyleTileShapeSelect; +typedef SHARED_PTR IfcFillStyleSelect; +typedef SHARED_PTR IfcGeometricSetSelect; +typedef SHARED_PTR IfcHatchLineDistanceSelect; +typedef SHARED_PTR IfcLayeredItem; +typedef SHARED_PTR IfcLibrarySelect; +typedef SHARED_PTR IfcLightDistributionDataSourceSelect; +typedef SHARED_PTR IfcMaterialSelect; +typedef SHARED_PTR IfcMeasureValue; +typedef SHARED_PTR IfcMetricValueSelect; +typedef SHARED_PTR IfcObjectReferenceSelect; +typedef SHARED_PTR IfcOrientationSelect; +typedef SHARED_PTR IfcPointOrVertexPoint; +typedef SHARED_PTR IfcPresentationStyleSelect; +typedef SHARED_PTR IfcShell; +typedef SHARED_PTR IfcSimpleValue; +typedef SHARED_PTR IfcSizeSelect; +typedef SHARED_PTR IfcSpecularHighlightSelect; +typedef SHARED_PTR IfcStructuralActivityAssignmentSelect; +typedef SHARED_PTR IfcSurfaceOrFaceSurface; +typedef SHARED_PTR IfcSurfaceStyleElementSelect; +typedef SHARED_PTR IfcSymbolStyleSelect; +typedef SHARED_PTR IfcTextFontSelect; +typedef SHARED_PTR IfcTextStyleSelect; +typedef SHARED_PTR IfcTrimmingSelect; +typedef SHARED_PTR IfcUnit; +typedef SHARED_PTR IfcValue; +typedef SHARED_PTR IfcVectorOrDirection; +typedef IfcLabel IfcBoxAlignment; +typedef IfcRatioMeasure IfcNormalisedRatioMeasure; +typedef IfcLengthMeasure IfcPositiveLengthMeasure; +typedef IfcPlaneAngleMeasure IfcPositivePlaneAngleMeasure; +typedef IfcRatioMeasure IfcPositiveRatioMeasure; +namespace IfcActionSourceTypeEnum {typedef enum {DEAD_LOAD_G, COMPLETION_G1, LIVE_LOAD_Q, SNOW_S, WIND_W, PRESTRESSING_P, SETTLEMENT_U, TEMPERATURE_T, EARTHQUAKE_E, FIRE, IMPULSE, IMPACT, TRANSPORT, ERECTION, PROPPING, SYSTEM_IMPERFECTION, SHRINKAGE, CREEP, LACK_OF_FIT, BUOYANCY, ICE, CURRENT, WAVE, RAIN, BRAKES, USERDEFINED, NOTDEFINED} IfcActionSourceTypeEnum; +std::string ToString(IfcActionSourceTypeEnum v); +IfcActionSourceTypeEnum FromString(const std::string& s);} +namespace IfcActionTypeEnum {typedef enum {PERMANENT_G, VARIABLE_Q, EXTRAORDINARY_A, USERDEFINED, NOTDEFINED} IfcActionTypeEnum; +std::string ToString(IfcActionTypeEnum v); +IfcActionTypeEnum FromString(const std::string& s);} +namespace IfcActuatorTypeEnum {typedef enum {ELECTRICACTUATOR, HANDOPERATEDACTUATOR, HYDRAULICACTUATOR, PNEUMATICACTUATOR, THERMOSTATICACTUATOR, USERDEFINED, NOTDEFINED} IfcActuatorTypeEnum; +std::string ToString(IfcActuatorTypeEnum v); +IfcActuatorTypeEnum FromString(const std::string& s);} +namespace IfcAddressTypeEnum {typedef enum {OFFICE, SITE, HOME, DISTRIBUTIONPOINT, USERDEFINED} IfcAddressTypeEnum; +std::string ToString(IfcAddressTypeEnum v); +IfcAddressTypeEnum FromString(const std::string& s);} +namespace IfcAheadOrBehind {typedef enum {AHEAD, BEHIND} IfcAheadOrBehind; +std::string ToString(IfcAheadOrBehind v); +IfcAheadOrBehind FromString(const std::string& s);} +namespace IfcAirTerminalBoxTypeEnum {typedef enum {CONSTANTFLOW, VARIABLEFLOWPRESSUREDEPENDANT, VARIABLEFLOWPRESSUREINDEPENDANT, USERDEFINED, NOTDEFINED} IfcAirTerminalBoxTypeEnum; +std::string ToString(IfcAirTerminalBoxTypeEnum v); +IfcAirTerminalBoxTypeEnum FromString(const std::string& s);} +namespace IfcAirTerminalTypeEnum {typedef enum {GRILLE, REGISTER, DIFFUSER, EYEBALL, IRIS, LINEARGRILLE, LINEARDIFFUSER, USERDEFINED, NOTDEFINED} IfcAirTerminalTypeEnum; +std::string ToString(IfcAirTerminalTypeEnum v); +IfcAirTerminalTypeEnum FromString(const std::string& s);} +namespace IfcAirToAirHeatRecoveryTypeEnum {typedef enum {FIXEDPLATECOUNTERFLOWEXCHANGER, FIXEDPLATECROSSFLOWEXCHANGER, FIXEDPLATEPARALLELFLOWEXCHANGER, ROTARYWHEEL, RUNAROUNDCOILLOOP, HEATPIPE, TWINTOWERENTHALPYRECOVERYLOOPS, THERMOSIPHONSEALEDTUBEHEATEXCHANGERS, THERMOSIPHONCOILTYPEHEATEXCHANGERS, USERDEFINED, NOTDEFINED} IfcAirToAirHeatRecoveryTypeEnum; +std::string ToString(IfcAirToAirHeatRecoveryTypeEnum v); +IfcAirToAirHeatRecoveryTypeEnum FromString(const std::string& s);} +namespace IfcAlarmTypeEnum {typedef enum {BELL, BREAKGLASSBUTTON, LIGHT, MANUALPULLBOX, SIREN, WHISTLE, USERDEFINED, NOTDEFINED} IfcAlarmTypeEnum; +std::string ToString(IfcAlarmTypeEnum v); +IfcAlarmTypeEnum FromString(const std::string& s);} +namespace IfcAnalysisModelTypeEnum {typedef enum {IN_PLANE_LOADING_2D, OUT_PLANE_LOADING_2D, LOADING_3D, USERDEFINED, NOTDEFINED} IfcAnalysisModelTypeEnum; +std::string ToString(IfcAnalysisModelTypeEnum v); +IfcAnalysisModelTypeEnum FromString(const std::string& s);} +namespace IfcAnalysisTheoryTypeEnum {typedef enum {FIRST_ORDER_THEORY, SECOND_ORDER_THEORY, THIRD_ORDER_THEORY, FULL_NONLINEAR_THEORY, USERDEFINED, NOTDEFINED} IfcAnalysisTheoryTypeEnum; +std::string ToString(IfcAnalysisTheoryTypeEnum v); +IfcAnalysisTheoryTypeEnum FromString(const std::string& s);} +namespace IfcArithmeticOperatorEnum {typedef enum {ADD, DIVIDE, MULTIPLY, SUBTRACT} IfcArithmeticOperatorEnum; +std::string ToString(IfcArithmeticOperatorEnum v); +IfcArithmeticOperatorEnum FromString(const std::string& s);} +namespace IfcAssemblyPlaceEnum {typedef enum {SITE, FACTORY, NOTDEFINED} IfcAssemblyPlaceEnum; +std::string ToString(IfcAssemblyPlaceEnum v); +IfcAssemblyPlaceEnum FromString(const std::string& s);} +namespace IfcBSplineCurveForm {typedef enum {POLYLINE_FORM, CIRCULAR_ARC, ELLIPTIC_ARC, PARABOLIC_ARC, HYPERBOLIC_ARC, UNSPECIFIED} IfcBSplineCurveForm; +std::string ToString(IfcBSplineCurveForm v); +IfcBSplineCurveForm FromString(const std::string& s);} +namespace IfcBeamTypeEnum {typedef enum {BEAM, JOIST, LINTEL, T_BEAM, USERDEFINED, NOTDEFINED} IfcBeamTypeEnum; +std::string ToString(IfcBeamTypeEnum v); +IfcBeamTypeEnum FromString(const std::string& s);} +namespace IfcBenchmarkEnum {typedef enum {GREATERTHAN, GREATERTHANOREQUALTO, LESSTHAN, LESSTHANOREQUALTO, EQUALTO, NOTEQUALTO} IfcBenchmarkEnum; +std::string ToString(IfcBenchmarkEnum v); +IfcBenchmarkEnum FromString(const std::string& s);} +namespace IfcBoilerTypeEnum {typedef enum {WATER, STEAM, USERDEFINED, NOTDEFINED} IfcBoilerTypeEnum; +std::string ToString(IfcBoilerTypeEnum v); +IfcBoilerTypeEnum FromString(const std::string& s);} +namespace IfcBooleanOperator {typedef enum {UNION, INTERSECTION, DIFFERENCE} IfcBooleanOperator; +std::string ToString(IfcBooleanOperator v); +IfcBooleanOperator FromString(const std::string& s);} +namespace IfcBuildingElementProxyTypeEnum {typedef enum {USERDEFINED, NOTDEFINED} IfcBuildingElementProxyTypeEnum; +std::string ToString(IfcBuildingElementProxyTypeEnum v); +IfcBuildingElementProxyTypeEnum FromString(const std::string& s);} +namespace IfcCableCarrierFittingTypeEnum {typedef enum {BEND, CROSS, REDUCER, TEE, USERDEFINED, NOTDEFINED} IfcCableCarrierFittingTypeEnum; +std::string ToString(IfcCableCarrierFittingTypeEnum v); +IfcCableCarrierFittingTypeEnum FromString(const std::string& s);} +namespace IfcCableCarrierSegmentTypeEnum {typedef enum {CABLELADDERSEGMENT, CABLETRAYSEGMENT, CABLETRUNKINGSEGMENT, CONDUITSEGMENT, USERDEFINED, NOTDEFINED} IfcCableCarrierSegmentTypeEnum; +std::string ToString(IfcCableCarrierSegmentTypeEnum v); +IfcCableCarrierSegmentTypeEnum FromString(const std::string& s);} +namespace IfcCableSegmentTypeEnum {typedef enum {CABLESEGMENT, CONDUCTORSEGMENT, USERDEFINED, NOTDEFINED} IfcCableSegmentTypeEnum; +std::string ToString(IfcCableSegmentTypeEnum v); +IfcCableSegmentTypeEnum FromString(const std::string& s);} +namespace IfcChangeActionEnum {typedef enum {NOCHANGE, MODIFIED, ADDED, DELETED, MODIFIEDADDED, MODIFIEDDELETED} IfcChangeActionEnum; +std::string ToString(IfcChangeActionEnum v); +IfcChangeActionEnum FromString(const std::string& s);} +namespace IfcChillerTypeEnum {typedef enum {AIRCOOLED, WATERCOOLED, HEATRECOVERY, USERDEFINED, NOTDEFINED} IfcChillerTypeEnum; +std::string ToString(IfcChillerTypeEnum v); +IfcChillerTypeEnum FromString(const std::string& s);} +namespace IfcCoilTypeEnum {typedef enum {DXCOOLINGCOIL, WATERCOOLINGCOIL, STEAMHEATINGCOIL, WATERHEATINGCOIL, ELECTRICHEATINGCOIL, GASHEATINGCOIL, USERDEFINED, NOTDEFINED} IfcCoilTypeEnum; +std::string ToString(IfcCoilTypeEnum v); +IfcCoilTypeEnum FromString(const std::string& s);} +namespace IfcColumnTypeEnum {typedef enum {COLUMN, USERDEFINED, NOTDEFINED} IfcColumnTypeEnum; +std::string ToString(IfcColumnTypeEnum v); +IfcColumnTypeEnum FromString(const std::string& s);} +namespace IfcCompressorTypeEnum {typedef enum {DYNAMIC, RECIPROCATING, ROTARY, SCROLL, TROCHOIDAL, SINGLESTAGE, BOOSTER, OPENTYPE, HERMETIC, SEMIHERMETIC, WELDEDSHELLHERMETIC, ROLLINGPISTON, ROTARYVANE, SINGLESCREW, TWINSCREW, USERDEFINED, NOTDEFINED} IfcCompressorTypeEnum; +std::string ToString(IfcCompressorTypeEnum v); +IfcCompressorTypeEnum FromString(const std::string& s);} +namespace IfcCondenserTypeEnum {typedef enum {WATERCOOLEDSHELLTUBE, WATERCOOLEDSHELLCOIL, WATERCOOLEDTUBEINTUBE, WATERCOOLEDBRAZEDPLATE, AIRCOOLED, EVAPORATIVECOOLED, USERDEFINED, NOTDEFINED} IfcCondenserTypeEnum; +std::string ToString(IfcCondenserTypeEnum v); +IfcCondenserTypeEnum FromString(const std::string& s);} +namespace IfcConnectionTypeEnum {typedef enum {ATPATH, ATSTART, ATEND, NOTDEFINED} IfcConnectionTypeEnum; +std::string ToString(IfcConnectionTypeEnum v); +IfcConnectionTypeEnum FromString(const std::string& s);} +namespace IfcConstraintEnum {typedef enum {HARD, SOFT, ADVISORY, USERDEFINED, NOTDEFINED} IfcConstraintEnum; +std::string ToString(IfcConstraintEnum v); +IfcConstraintEnum FromString(const std::string& s);} +namespace IfcControllerTypeEnum {typedef enum {FLOATING, PROPORTIONAL, PROPORTIONALINTEGRAL, PROPORTIONALINTEGRALDERIVATIVE, TIMEDTWOPOSITION, TWOPOSITION, USERDEFINED, NOTDEFINED} IfcControllerTypeEnum; +std::string ToString(IfcControllerTypeEnum v); +IfcControllerTypeEnum FromString(const std::string& s);} +namespace IfcCooledBeamTypeEnum {typedef enum {ACTIVE, PASSIVE, USERDEFINED, NOTDEFINED} IfcCooledBeamTypeEnum; +std::string ToString(IfcCooledBeamTypeEnum v); +IfcCooledBeamTypeEnum FromString(const std::string& s);} +namespace IfcCoolingTowerTypeEnum {typedef enum {NATURALDRAFT, MECHANICALINDUCEDDRAFT, MECHANICALFORCEDDRAFT, USERDEFINED, NOTDEFINED} IfcCoolingTowerTypeEnum; +std::string ToString(IfcCoolingTowerTypeEnum v); +IfcCoolingTowerTypeEnum FromString(const std::string& s);} +namespace IfcCostScheduleTypeEnum {typedef enum {BUDGET, COSTPLAN, ESTIMATE, TENDER, PRICEDBILLOFQUANTITIES, UNPRICEDBILLOFQUANTITIES, SCHEDULEOFRATES, USERDEFINED, NOTDEFINED} IfcCostScheduleTypeEnum; +std::string ToString(IfcCostScheduleTypeEnum v); +IfcCostScheduleTypeEnum FromString(const std::string& s);} +namespace IfcCoveringTypeEnum {typedef enum {CEILING, FLOORING, CLADDING, ROOFING, INSULATION, MEMBRANE, SLEEVING, WRAPPING, USERDEFINED, NOTDEFINED} IfcCoveringTypeEnum; +std::string ToString(IfcCoveringTypeEnum v); +IfcCoveringTypeEnum FromString(const std::string& s);} +namespace IfcCurrencyEnum {typedef enum {AED, AES, ATS, AUD, BBD, BEG, BGL, BHD, BMD, BND, BRL, BSD, BWP, BZD, CAD, CBD, CHF, CLP, CNY, CYS, CZK, DDP, DEM, DKK, EGL, EST, EUR, FAK, FIM, FJD, FKP, FRF, GBP, GIP, GMD, GRX, HKD, HUF, ICK, IDR, ILS, INR, IRP, ITL, JMD, JOD, JPY, KES, KRW, KWD, KYD, LKR, LUF, MTL, MUR, MXN, MYR, NLG, NZD, OMR, PGK, PHP, PKR, PLN, PTN, QAR, RUR, SAR, SCR, SEK, SGD, SKP, THB, TRL, TTD, TWD, USD, VEB, VND, XEU, ZAR, ZWD, NOK} IfcCurrencyEnum; +std::string ToString(IfcCurrencyEnum v); +IfcCurrencyEnum FromString(const std::string& s);} +namespace IfcCurtainWallTypeEnum {typedef enum {USERDEFINED, NOTDEFINED} IfcCurtainWallTypeEnum; +std::string ToString(IfcCurtainWallTypeEnum v); +IfcCurtainWallTypeEnum FromString(const std::string& s);} +namespace IfcDamperTypeEnum {typedef enum {CONTROLDAMPER, FIREDAMPER, SMOKEDAMPER, FIRESMOKEDAMPER, BACKDRAFTDAMPER, RELIEFDAMPER, BLASTDAMPER, GRAVITYDAMPER, GRAVITYRELIEFDAMPER, BALANCINGDAMPER, FUMEHOODEXHAUST, USERDEFINED, NOTDEFINED} IfcDamperTypeEnum; +std::string ToString(IfcDamperTypeEnum v); +IfcDamperTypeEnum FromString(const std::string& s);} +namespace IfcDataOriginEnum {typedef enum {MEASURED, PREDICTED, SIMULATED, USERDEFINED, NOTDEFINED} IfcDataOriginEnum; +std::string ToString(IfcDataOriginEnum v); +IfcDataOriginEnum FromString(const std::string& s);} +namespace IfcDerivedUnitEnum {typedef enum {ANGULARVELOCITYUNIT, COMPOUNDPLANEANGLEUNIT, DYNAMICVISCOSITYUNIT, HEATFLUXDENSITYUNIT, INTEGERCOUNTRATEUNIT, ISOTHERMALMOISTURECAPACITYUNIT, KINEMATICVISCOSITYUNIT, LINEARVELOCITYUNIT, MASSDENSITYUNIT, MASSFLOWRATEUNIT, MOISTUREDIFFUSIVITYUNIT, MOLECULARWEIGHTUNIT, SPECIFICHEATCAPACITYUNIT, THERMALADMITTANCEUNIT, THERMALCONDUCTANCEUNIT, THERMALRESISTANCEUNIT, THERMALTRANSMITTANCEUNIT, VAPORPERMEABILITYUNIT, VOLUMETRICFLOWRATEUNIT, ROTATIONALFREQUENCYUNIT, TORQUEUNIT, MOMENTOFINERTIAUNIT, LINEARMOMENTUNIT, LINEARFORCEUNIT, PLANARFORCEUNIT, MODULUSOFELASTICITYUNIT, SHEARMODULUSUNIT, LINEARSTIFFNESSUNIT, ROTATIONALSTIFFNESSUNIT, MODULUSOFSUBGRADEREACTIONUNIT, ACCELERATIONUNIT, CURVATUREUNIT, HEATINGVALUEUNIT, IONCONCENTRATIONUNIT, LUMINOUSINTENSITYDISTRIBUTIONUNIT, MASSPERLENGTHUNIT, MODULUSOFLINEARSUBGRADEREACTIONUNIT, MODULUSOFROTATIONALSUBGRADEREACTIONUNIT, PHUNIT, ROTATIONALMASSUNIT, SECTIONAREAINTEGRALUNIT, SECTIONMODULUSUNIT, SOUNDPOWERUNIT, SOUNDPRESSUREUNIT, TEMPERATUREGRADIENTUNIT, THERMALEXPANSIONCOEFFICIENTUNIT, WARPINGCONSTANTUNIT, WARPINGMOMENTUNIT, USERDEFINED} IfcDerivedUnitEnum; +std::string ToString(IfcDerivedUnitEnum v); +IfcDerivedUnitEnum FromString(const std::string& s);} +namespace IfcDimensionExtentUsage {typedef enum {ORIGIN, TARGET} IfcDimensionExtentUsage; +std::string ToString(IfcDimensionExtentUsage v); +IfcDimensionExtentUsage FromString(const std::string& s);} +namespace IfcDirectionSenseEnum {typedef enum {POSITIVE, NEGATIVE} IfcDirectionSenseEnum; +std::string ToString(IfcDirectionSenseEnum v); +IfcDirectionSenseEnum FromString(const std::string& s);} +namespace IfcDistributionChamberElementTypeEnum {typedef enum {FORMEDDUCT, INSPECTIONCHAMBER, INSPECTIONPIT, MANHOLE, METERCHAMBER, SUMP, TRENCH, VALVECHAMBER, USERDEFINED, NOTDEFINED} IfcDistributionChamberElementTypeEnum; +std::string ToString(IfcDistributionChamberElementTypeEnum v); +IfcDistributionChamberElementTypeEnum FromString(const std::string& s);} +namespace IfcDocumentConfidentialityEnum {typedef enum {PUBLIC, RESTRICTED, CONFIDENTIAL, PERSONAL, USERDEFINED, NOTDEFINED} IfcDocumentConfidentialityEnum; +std::string ToString(IfcDocumentConfidentialityEnum v); +IfcDocumentConfidentialityEnum FromString(const std::string& s);} +namespace IfcDocumentStatusEnum {typedef enum {DRAFT, FINALDRAFT, FINAL, REVISION, NOTDEFINED} IfcDocumentStatusEnum; +std::string ToString(IfcDocumentStatusEnum v); +IfcDocumentStatusEnum FromString(const std::string& s);} +namespace IfcDoorPanelOperationEnum {typedef enum {SWINGING, DOUBLE_ACTING, SLIDING, FOLDING, REVOLVING, ROLLINGUP, USERDEFINED, NOTDEFINED} IfcDoorPanelOperationEnum; +std::string ToString(IfcDoorPanelOperationEnum v); +IfcDoorPanelOperationEnum FromString(const std::string& s);} +namespace IfcDoorPanelPositionEnum {typedef enum {LEFT, MIDDLE, RIGHT, NOTDEFINED} IfcDoorPanelPositionEnum; +std::string ToString(IfcDoorPanelPositionEnum v); +IfcDoorPanelPositionEnum FromString(const std::string& s);} +namespace IfcDoorStyleConstructionEnum {typedef enum {ALUMINIUM, HIGH_GRADE_STEEL, STEEL, WOOD, ALUMINIUM_WOOD, ALUMINIUM_PLASTIC, PLASTIC, USERDEFINED, NOTDEFINED} IfcDoorStyleConstructionEnum; +std::string ToString(IfcDoorStyleConstructionEnum v); +IfcDoorStyleConstructionEnum FromString(const std::string& s);} +namespace IfcDoorStyleOperationEnum {typedef enum {SINGLE_SWING_LEFT, SINGLE_SWING_RIGHT, DOUBLE_DOOR_SINGLE_SWING, DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT, DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT, DOUBLE_SWING_LEFT, DOUBLE_SWING_RIGHT, DOUBLE_DOOR_DOUBLE_SWING, SLIDING_TO_LEFT, SLIDING_TO_RIGHT, DOUBLE_DOOR_SLIDING, FOLDING_TO_LEFT, FOLDING_TO_RIGHT, DOUBLE_DOOR_FOLDING, REVOLVING, ROLLINGUP, USERDEFINED, NOTDEFINED} IfcDoorStyleOperationEnum; +std::string ToString(IfcDoorStyleOperationEnum v); +IfcDoorStyleOperationEnum FromString(const std::string& s);} +namespace IfcDuctFittingTypeEnum {typedef enum {BEND, CONNECTOR, ENTRY, EXIT, JUNCTION, OBSTRUCTION, TRANSITION, USERDEFINED, NOTDEFINED} IfcDuctFittingTypeEnum; +std::string ToString(IfcDuctFittingTypeEnum v); +IfcDuctFittingTypeEnum FromString(const std::string& s);} +namespace IfcDuctSegmentTypeEnum {typedef enum {RIGIDSEGMENT, FLEXIBLESEGMENT, USERDEFINED, NOTDEFINED} IfcDuctSegmentTypeEnum; +std::string ToString(IfcDuctSegmentTypeEnum v); +IfcDuctSegmentTypeEnum FromString(const std::string& s);} +namespace IfcDuctSilencerTypeEnum {typedef enum {FLATOVAL, RECTANGULAR, ROUND, USERDEFINED, NOTDEFINED} IfcDuctSilencerTypeEnum; +std::string ToString(IfcDuctSilencerTypeEnum v); +IfcDuctSilencerTypeEnum FromString(const std::string& s);} +namespace IfcElectricApplianceTypeEnum {typedef enum {COMPUTER, DIRECTWATERHEATER, DISHWASHER, ELECTRICCOOKER, ELECTRICHEATER, FACSIMILE, FREESTANDINGFAN, FREEZER, FRIDGE_FREEZER, HANDDRYER, INDIRECTWATERHEATER, MICROWAVE, PHOTOCOPIER, PRINTER, REFRIGERATOR, RADIANTHEATER, SCANNER, TELEPHONE, TUMBLEDRYER, TV, VENDINGMACHINE, WASHINGMACHINE, WATERHEATER, WATERCOOLER, USERDEFINED, NOTDEFINED} IfcElectricApplianceTypeEnum; +std::string ToString(IfcElectricApplianceTypeEnum v); +IfcElectricApplianceTypeEnum FromString(const std::string& s);} +namespace IfcElectricCurrentEnum {typedef enum {ALTERNATING, DIRECT, NOTDEFINED} IfcElectricCurrentEnum; +std::string ToString(IfcElectricCurrentEnum v); +IfcElectricCurrentEnum FromString(const std::string& s);} +namespace IfcElectricDistributionPointFunctionEnum {typedef enum {ALARMPANEL, CONSUMERUNIT, CONTROLPANEL, DISTRIBUTIONBOARD, GASDETECTORPANEL, INDICATORPANEL, MIMICPANEL, MOTORCONTROLCENTRE, SWITCHBOARD, USERDEFINED, NOTDEFINED} IfcElectricDistributionPointFunctionEnum; +std::string ToString(IfcElectricDistributionPointFunctionEnum v); +IfcElectricDistributionPointFunctionEnum FromString(const std::string& s);} +namespace IfcElectricFlowStorageDeviceTypeEnum {typedef enum {BATTERY, CAPACITORBANK, HARMONICFILTER, INDUCTORBANK, UPS, USERDEFINED, NOTDEFINED} IfcElectricFlowStorageDeviceTypeEnum; +std::string ToString(IfcElectricFlowStorageDeviceTypeEnum v); +IfcElectricFlowStorageDeviceTypeEnum FromString(const std::string& s);} +namespace IfcElectricGeneratorTypeEnum {typedef enum {USERDEFINED, NOTDEFINED} IfcElectricGeneratorTypeEnum; +std::string ToString(IfcElectricGeneratorTypeEnum v); +IfcElectricGeneratorTypeEnum FromString(const std::string& s);} +namespace IfcElectricHeaterTypeEnum {typedef enum {ELECTRICPOINTHEATER, ELECTRICCABLEHEATER, ELECTRICMATHEATER, USERDEFINED, NOTDEFINED} IfcElectricHeaterTypeEnum; +std::string ToString(IfcElectricHeaterTypeEnum v); +IfcElectricHeaterTypeEnum FromString(const std::string& s);} +namespace IfcElectricMotorTypeEnum {typedef enum {DC, INDUCTION, POLYPHASE, RELUCTANCESYNCHRONOUS, SYNCHRONOUS, USERDEFINED, NOTDEFINED} IfcElectricMotorTypeEnum; +std::string ToString(IfcElectricMotorTypeEnum v); +IfcElectricMotorTypeEnum FromString(const std::string& s);} +namespace IfcElectricTimeControlTypeEnum {typedef enum {TIMECLOCK, TIMEDELAY, RELAY, USERDEFINED, NOTDEFINED} IfcElectricTimeControlTypeEnum; +std::string ToString(IfcElectricTimeControlTypeEnum v); +IfcElectricTimeControlTypeEnum FromString(const std::string& s);} +namespace IfcElementAssemblyTypeEnum {typedef enum {ACCESSORY_ASSEMBLY, ARCH, BEAM_GRID, BRACED_FRAME, GIRDER, REINFORCEMENT_UNIT, RIGID_FRAME, SLAB_FIELD, TRUSS, USERDEFINED, NOTDEFINED} IfcElementAssemblyTypeEnum; +std::string ToString(IfcElementAssemblyTypeEnum v); +IfcElementAssemblyTypeEnum FromString(const std::string& s);} +namespace IfcElementCompositionEnum {typedef enum {COMPLEX, ELEMENT, PARTIAL} IfcElementCompositionEnum; +std::string ToString(IfcElementCompositionEnum v); +IfcElementCompositionEnum FromString(const std::string& s);} +namespace IfcEnergySequenceEnum {typedef enum {PRIMARY, SECONDARY, TERTIARY, AUXILIARY, USERDEFINED, NOTDEFINED} IfcEnergySequenceEnum; +std::string ToString(IfcEnergySequenceEnum v); +IfcEnergySequenceEnum FromString(const std::string& s);} +namespace IfcEnvironmentalImpactCategoryEnum {typedef enum {COMBINEDVALUE, DISPOSAL, EXTRACTION, INSTALLATION, MANUFACTURE, TRANSPORTATION, USERDEFINED, NOTDEFINED} IfcEnvironmentalImpactCategoryEnum; +std::string ToString(IfcEnvironmentalImpactCategoryEnum v); +IfcEnvironmentalImpactCategoryEnum FromString(const std::string& s);} +namespace IfcEvaporativeCoolerTypeEnum {typedef enum {DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER, DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER, DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER, DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER, DIRECTEVAPORATIVEAIRWASHER, INDIRECTEVAPORATIVEPACKAGEAIRCOOLER, INDIRECTEVAPORATIVEWETCOIL, INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER, INDIRECTDIRECTCOMBINATION, USERDEFINED, NOTDEFINED} IfcEvaporativeCoolerTypeEnum; +std::string ToString(IfcEvaporativeCoolerTypeEnum v); +IfcEvaporativeCoolerTypeEnum FromString(const std::string& s);} +namespace IfcEvaporatorTypeEnum {typedef enum {DIRECTEXPANSIONSHELLANDTUBE, DIRECTEXPANSIONTUBEINTUBE, DIRECTEXPANSIONBRAZEDPLATE, FLOODEDSHELLANDTUBE, SHELLANDCOIL, USERDEFINED, NOTDEFINED} IfcEvaporatorTypeEnum; +std::string ToString(IfcEvaporatorTypeEnum v); +IfcEvaporatorTypeEnum FromString(const std::string& s);} +namespace IfcFanTypeEnum {typedef enum {CENTRIFUGALFORWARDCURVED, CENTRIFUGALRADIAL, CENTRIFUGALBACKWARDINCLINEDCURVED, CENTRIFUGALAIRFOIL, TUBEAXIAL, VANEAXIAL, PROPELLORAXIAL, USERDEFINED, NOTDEFINED} IfcFanTypeEnum; +std::string ToString(IfcFanTypeEnum v); +IfcFanTypeEnum FromString(const std::string& s);} +namespace IfcFilterTypeEnum {typedef enum {AIRPARTICLEFILTER, ODORFILTER, OILFILTER, STRAINER, WATERFILTER, USERDEFINED, NOTDEFINED} IfcFilterTypeEnum; +std::string ToString(IfcFilterTypeEnum v); +IfcFilterTypeEnum FromString(const std::string& s);} +namespace IfcFireSuppressionTerminalTypeEnum {typedef enum {BREECHINGINLET, FIREHYDRANT, HOSEREEL, SPRINKLER, SPRINKLERDEFLECTOR, USERDEFINED, NOTDEFINED} IfcFireSuppressionTerminalTypeEnum; +std::string ToString(IfcFireSuppressionTerminalTypeEnum v); +IfcFireSuppressionTerminalTypeEnum FromString(const std::string& s);} +namespace IfcFlowDirectionEnum {typedef enum {SOURCE, SINK, SOURCEANDSINK, NOTDEFINED} IfcFlowDirectionEnum; +std::string ToString(IfcFlowDirectionEnum v); +IfcFlowDirectionEnum FromString(const std::string& s);} +namespace IfcFlowInstrumentTypeEnum {typedef enum {PRESSUREGAUGE, THERMOMETER, AMMETER, FREQUENCYMETER, POWERFACTORMETER, PHASEANGLEMETER, VOLTMETER_PEAK, VOLTMETER_RMS, USERDEFINED, NOTDEFINED} IfcFlowInstrumentTypeEnum; +std::string ToString(IfcFlowInstrumentTypeEnum v); +IfcFlowInstrumentTypeEnum FromString(const std::string& s);} +namespace IfcFlowMeterTypeEnum {typedef enum {ELECTRICMETER, ENERGYMETER, FLOWMETER, GASMETER, OILMETER, WATERMETER, USERDEFINED, NOTDEFINED} IfcFlowMeterTypeEnum; +std::string ToString(IfcFlowMeterTypeEnum v); +IfcFlowMeterTypeEnum FromString(const std::string& s);} +namespace IfcFootingTypeEnum {typedef enum {FOOTING_BEAM, PAD_FOOTING, PILE_CAP, STRIP_FOOTING, USERDEFINED, NOTDEFINED} IfcFootingTypeEnum; +std::string ToString(IfcFootingTypeEnum v); +IfcFootingTypeEnum FromString(const std::string& s);} +namespace IfcGasTerminalTypeEnum {typedef enum {GASAPPLIANCE, GASBOOSTER, GASBURNER, USERDEFINED, NOTDEFINED} IfcGasTerminalTypeEnum; +std::string ToString(IfcGasTerminalTypeEnum v); +IfcGasTerminalTypeEnum FromString(const std::string& s);} +namespace IfcGeometricProjectionEnum {typedef enum {GRAPH_VIEW, SKETCH_VIEW, MODEL_VIEW, PLAN_VIEW, REFLECTED_PLAN_VIEW, SECTION_VIEW, ELEVATION_VIEW, USERDEFINED, NOTDEFINED} IfcGeometricProjectionEnum; +std::string ToString(IfcGeometricProjectionEnum v); +IfcGeometricProjectionEnum FromString(const std::string& s);} +namespace IfcGlobalOrLocalEnum {typedef enum {GLOBAL_COORDS, LOCAL_COORDS} IfcGlobalOrLocalEnum; +std::string ToString(IfcGlobalOrLocalEnum v); +IfcGlobalOrLocalEnum FromString(const std::string& s);} +namespace IfcHeatExchangerTypeEnum {typedef enum {PLATE, SHELLANDTUBE, USERDEFINED, NOTDEFINED} IfcHeatExchangerTypeEnum; +std::string ToString(IfcHeatExchangerTypeEnum v); +IfcHeatExchangerTypeEnum FromString(const std::string& s);} +namespace IfcHumidifierTypeEnum {typedef enum {STEAMINJECTION, ADIABATICAIRWASHER, ADIABATICPAN, ADIABATICWETTEDELEMENT, ADIABATICATOMIZING, ADIABATICULTRASONIC, ADIABATICRIGIDMEDIA, ADIABATICCOMPRESSEDAIRNOZZLE, ASSISTEDELECTRIC, ASSISTEDNATURALGAS, ASSISTEDPROPANE, ASSISTEDBUTANE, ASSISTEDSTEAM, USERDEFINED, NOTDEFINED} IfcHumidifierTypeEnum; +std::string ToString(IfcHumidifierTypeEnum v); +IfcHumidifierTypeEnum FromString(const std::string& s);} +namespace IfcInternalOrExternalEnum {typedef enum {INTERNAL, EXTERNAL, NOTDEFINED} IfcInternalOrExternalEnum; +std::string ToString(IfcInternalOrExternalEnum v); +IfcInternalOrExternalEnum FromString(const std::string& s);} +namespace IfcInventoryTypeEnum {typedef enum {ASSETINVENTORY, SPACEINVENTORY, FURNITUREINVENTORY, USERDEFINED, NOTDEFINED} IfcInventoryTypeEnum; +std::string ToString(IfcInventoryTypeEnum v); +IfcInventoryTypeEnum FromString(const std::string& s);} +namespace IfcJunctionBoxTypeEnum {typedef enum {USERDEFINED, NOTDEFINED} IfcJunctionBoxTypeEnum; +std::string ToString(IfcJunctionBoxTypeEnum v); +IfcJunctionBoxTypeEnum FromString(const std::string& s);} +namespace IfcLampTypeEnum {typedef enum {COMPACTFLUORESCENT, FLUORESCENT, HIGHPRESSUREMERCURY, HIGHPRESSURESODIUM, METALHALIDE, TUNGSTENFILAMENT, USERDEFINED, NOTDEFINED} IfcLampTypeEnum; +std::string ToString(IfcLampTypeEnum v); +IfcLampTypeEnum FromString(const std::string& s);} +namespace IfcLayerSetDirectionEnum {typedef enum {AXIS1, AXIS2, AXIS3} IfcLayerSetDirectionEnum; +std::string ToString(IfcLayerSetDirectionEnum v); +IfcLayerSetDirectionEnum FromString(const std::string& s);} +namespace IfcLightDistributionCurveEnum {typedef enum {TYPE_A, TYPE_B, TYPE_C, NOTDEFINED} IfcLightDistributionCurveEnum; +std::string ToString(IfcLightDistributionCurveEnum v); +IfcLightDistributionCurveEnum FromString(const std::string& s);} +namespace IfcLightEmissionSourceEnum {typedef enum {COMPACTFLUORESCENT, FLUORESCENT, HIGHPRESSUREMERCURY, HIGHPRESSURESODIUM, LIGHTEMITTINGDIODE, LOWPRESSURESODIUM, LOWVOLTAGEHALOGEN, MAINVOLTAGEHALOGEN, METALHALIDE, TUNGSTENFILAMENT, NOTDEFINED} IfcLightEmissionSourceEnum; +std::string ToString(IfcLightEmissionSourceEnum v); +IfcLightEmissionSourceEnum FromString(const std::string& s);} +namespace IfcLightFixtureTypeEnum {typedef enum {POINTSOURCE, DIRECTIONSOURCE, USERDEFINED, NOTDEFINED} IfcLightFixtureTypeEnum; +std::string ToString(IfcLightFixtureTypeEnum v); +IfcLightFixtureTypeEnum FromString(const std::string& s);} +namespace IfcLoadGroupTypeEnum {typedef enum {LOAD_GROUP, LOAD_CASE, LOAD_COMBINATION_GROUP, LOAD_COMBINATION, USERDEFINED, NOTDEFINED} IfcLoadGroupTypeEnum; +std::string ToString(IfcLoadGroupTypeEnum v); +IfcLoadGroupTypeEnum FromString(const std::string& s);} +namespace IfcLogicalOperatorEnum {typedef enum {LOGICALAND, LOGICALOR} IfcLogicalOperatorEnum; +std::string ToString(IfcLogicalOperatorEnum v); +IfcLogicalOperatorEnum FromString(const std::string& s);} +namespace IfcMemberTypeEnum {typedef enum {BRACE, CHORD, COLLAR, MEMBER, MULLION, PLATE, POST, PURLIN, RAFTER, STRINGER, STRUT, STUD, USERDEFINED, NOTDEFINED} IfcMemberTypeEnum; +std::string ToString(IfcMemberTypeEnum v); +IfcMemberTypeEnum FromString(const std::string& s);} +namespace IfcMotorConnectionTypeEnum {typedef enum {BELTDRIVE, COUPLING, DIRECTDRIVE, USERDEFINED, NOTDEFINED} IfcMotorConnectionTypeEnum; +std::string ToString(IfcMotorConnectionTypeEnum v); +IfcMotorConnectionTypeEnum FromString(const std::string& s);} +namespace IfcNullStyle {typedef enum {IFC_NULL, } IfcNullStyle; +std::string ToString(IfcNullStyle v); +IfcNullStyle FromString(const std::string& s);} +namespace IfcObjectTypeEnum {typedef enum {PRODUCT, PROCESS, CONTROL, RESOURCE, ACTOR, GROUP, PROJECT, NOTDEFINED} IfcObjectTypeEnum; +std::string ToString(IfcObjectTypeEnum v); +IfcObjectTypeEnum FromString(const std::string& s);} +namespace IfcObjectiveEnum {typedef enum {CODECOMPLIANCE, DESIGNINTENT, HEALTHANDSAFETY, REQUIREMENT, SPECIFICATION, TRIGGERCONDITION, USERDEFINED, NOTDEFINED} IfcObjectiveEnum; +std::string ToString(IfcObjectiveEnum v); +IfcObjectiveEnum FromString(const std::string& s);} +namespace IfcOccupantTypeEnum {typedef enum {ASSIGNEE, ASSIGNOR, LESSEE, LESSOR, LETTINGAGENT, OWNER, TENANT, USERDEFINED, NOTDEFINED} IfcOccupantTypeEnum; +std::string ToString(IfcOccupantTypeEnum v); +IfcOccupantTypeEnum FromString(const std::string& s);} +namespace IfcOutletTypeEnum {typedef enum {AUDIOVISUALOUTLET, COMMUNICATIONSOUTLET, POWEROUTLET, USERDEFINED, NOTDEFINED} IfcOutletTypeEnum; +std::string ToString(IfcOutletTypeEnum v); +IfcOutletTypeEnum FromString(const std::string& s);} +namespace IfcPermeableCoveringOperationEnum {typedef enum {GRILL, LOUVER, SCREEN, USERDEFINED, NOTDEFINED} IfcPermeableCoveringOperationEnum; +std::string ToString(IfcPermeableCoveringOperationEnum v); +IfcPermeableCoveringOperationEnum FromString(const std::string& s);} +namespace IfcPhysicalOrVirtualEnum {typedef enum {PHYSICAL, VIRTUAL, NOTDEFINED} IfcPhysicalOrVirtualEnum; +std::string ToString(IfcPhysicalOrVirtualEnum v); +IfcPhysicalOrVirtualEnum FromString(const std::string& s);} +namespace IfcPileConstructionEnum {typedef enum {CAST_IN_PLACE, COMPOSITE, PRECAST_CONCRETE, PREFAB_STEEL, USERDEFINED, NOTDEFINED} IfcPileConstructionEnum; +std::string ToString(IfcPileConstructionEnum v); +IfcPileConstructionEnum FromString(const std::string& s);} +namespace IfcPileTypeEnum {typedef enum {COHESION, FRICTION, SUPPORT, USERDEFINED, NOTDEFINED} IfcPileTypeEnum; +std::string ToString(IfcPileTypeEnum v); +IfcPileTypeEnum FromString(const std::string& s);} +namespace IfcPipeFittingTypeEnum {typedef enum {BEND, CONNECTOR, ENTRY, EXIT, JUNCTION, OBSTRUCTION, TRANSITION, USERDEFINED, NOTDEFINED} IfcPipeFittingTypeEnum; +std::string ToString(IfcPipeFittingTypeEnum v); +IfcPipeFittingTypeEnum FromString(const std::string& s);} +namespace IfcPipeSegmentTypeEnum {typedef enum {FLEXIBLESEGMENT, RIGIDSEGMENT, GUTTER, SPOOL, USERDEFINED, NOTDEFINED} IfcPipeSegmentTypeEnum; +std::string ToString(IfcPipeSegmentTypeEnum v); +IfcPipeSegmentTypeEnum FromString(const std::string& s);} +namespace IfcPlateTypeEnum {typedef enum {CURTAIN_PANEL, SHEET, USERDEFINED, NOTDEFINED} IfcPlateTypeEnum; +std::string ToString(IfcPlateTypeEnum v); +IfcPlateTypeEnum FromString(const std::string& s);} +namespace IfcProcedureTypeEnum {typedef enum {ADVICE_CAUTION, ADVICE_NOTE, ADVICE_WARNING, CALIBRATION, DIAGNOSTIC, SHUTDOWN, STARTUP, USERDEFINED, NOTDEFINED} IfcProcedureTypeEnum; +std::string ToString(IfcProcedureTypeEnum v); +IfcProcedureTypeEnum FromString(const std::string& s);} +namespace IfcProfileTypeEnum {typedef enum {CURVE, AREA} IfcProfileTypeEnum; +std::string ToString(IfcProfileTypeEnum v); +IfcProfileTypeEnum FromString(const std::string& s);} +namespace IfcProjectOrderRecordTypeEnum {typedef enum {CHANGE, MAINTENANCE, MOVE, PURCHASE, WORK, USERDEFINED, NOTDEFINED} IfcProjectOrderRecordTypeEnum; +std::string ToString(IfcProjectOrderRecordTypeEnum v); +IfcProjectOrderRecordTypeEnum FromString(const std::string& s);} +namespace IfcProjectOrderTypeEnum {typedef enum {CHANGEORDER, MAINTENANCEWORKORDER, MOVEORDER, PURCHASEORDER, WORKORDER, USERDEFINED, NOTDEFINED} IfcProjectOrderTypeEnum; +std::string ToString(IfcProjectOrderTypeEnum v); +IfcProjectOrderTypeEnum FromString(const std::string& s);} +namespace IfcProjectedOrTrueLengthEnum {typedef enum {PROJECTED_LENGTH, TRUE_LENGTH} IfcProjectedOrTrueLengthEnum; +std::string ToString(IfcProjectedOrTrueLengthEnum v); +IfcProjectedOrTrueLengthEnum FromString(const std::string& s);} +namespace IfcPropertySourceEnum {typedef enum {DESIGN, DESIGNMAXIMUM, DESIGNMINIMUM, SIMULATED, ASBUILT, COMMISSIONING, MEASURED, USERDEFINED, NOTKNOWN} IfcPropertySourceEnum; +std::string ToString(IfcPropertySourceEnum v); +IfcPropertySourceEnum FromString(const std::string& s);} +namespace IfcProtectiveDeviceTypeEnum {typedef enum {FUSEDISCONNECTOR, CIRCUITBREAKER, EARTHFAILUREDEVICE, RESIDUALCURRENTCIRCUITBREAKER, RESIDUALCURRENTSWITCH, VARISTOR, USERDEFINED, NOTDEFINED} IfcProtectiveDeviceTypeEnum; +std::string ToString(IfcProtectiveDeviceTypeEnum v); +IfcProtectiveDeviceTypeEnum FromString(const std::string& s);} +namespace IfcPumpTypeEnum {typedef enum {CIRCULATOR, ENDSUCTION, SPLITCASE, VERTICALINLINE, VERTICALTURBINE, USERDEFINED, NOTDEFINED} IfcPumpTypeEnum; +std::string ToString(IfcPumpTypeEnum v); +IfcPumpTypeEnum FromString(const std::string& s);} +namespace IfcRailingTypeEnum {typedef enum {HANDRAIL, GUARDRAIL, BALUSTRADE, USERDEFINED, NOTDEFINED} IfcRailingTypeEnum; +std::string ToString(IfcRailingTypeEnum v); +IfcRailingTypeEnum FromString(const std::string& s);} +namespace IfcRampFlightTypeEnum {typedef enum {STRAIGHT, SPIRAL, USERDEFINED, NOTDEFINED} IfcRampFlightTypeEnum; +std::string ToString(IfcRampFlightTypeEnum v); +IfcRampFlightTypeEnum FromString(const std::string& s);} +namespace IfcRampTypeEnum {typedef enum {STRAIGHT_RUN_RAMP, TWO_STRAIGHT_RUN_RAMP, QUARTER_TURN_RAMP, TWO_QUARTER_TURN_RAMP, HALF_TURN_RAMP, SPIRAL_RAMP, USERDEFINED, NOTDEFINED} IfcRampTypeEnum; +std::string ToString(IfcRampTypeEnum v); +IfcRampTypeEnum FromString(const std::string& s);} +namespace IfcReflectanceMethodEnum {typedef enum {BLINN, FLAT, GLASS, MATT, METAL, MIRROR, PHONG, PLASTIC, STRAUSS, NOTDEFINED} IfcReflectanceMethodEnum; +std::string ToString(IfcReflectanceMethodEnum v); +IfcReflectanceMethodEnum FromString(const std::string& s);} +namespace IfcReinforcingBarRoleEnum {typedef enum {MAIN, SHEAR, LIGATURE, STUD, PUNCHING, EDGE, RING, USERDEFINED, NOTDEFINED} IfcReinforcingBarRoleEnum; +std::string ToString(IfcReinforcingBarRoleEnum v); +IfcReinforcingBarRoleEnum FromString(const std::string& s);} +namespace IfcReinforcingBarSurfaceEnum {typedef enum {PLAIN, TEXTURED} IfcReinforcingBarSurfaceEnum; +std::string ToString(IfcReinforcingBarSurfaceEnum v); +IfcReinforcingBarSurfaceEnum FromString(const std::string& s);} +namespace IfcResourceConsumptionEnum {typedef enum {CONSUMED, PARTIALLYCONSUMED, NOTCONSUMED, OCCUPIED, PARTIALLYOCCUPIED, NOTOCCUPIED, USERDEFINED, NOTDEFINED} IfcResourceConsumptionEnum; +std::string ToString(IfcResourceConsumptionEnum v); +IfcResourceConsumptionEnum FromString(const std::string& s);} +namespace IfcRibPlateDirectionEnum {typedef enum {DIRECTION_X, DIRECTION_Y} IfcRibPlateDirectionEnum; +std::string ToString(IfcRibPlateDirectionEnum v); +IfcRibPlateDirectionEnum FromString(const std::string& s);} +namespace IfcRoleEnum {typedef enum {SUPPLIER, MANUFACTURER, CONTRACTOR, SUBCONTRACTOR, ARCHITECT, STRUCTURALENGINEER, COSTENGINEER, CLIENT, BUILDINGOWNER, BUILDINGOPERATOR, MECHANICALENGINEER, ELECTRICALENGINEER, PROJECTMANAGER, FACILITIESMANAGER, CIVILENGINEER, COMISSIONINGENGINEER, ENGINEER, OWNER, CONSULTANT, CONSTRUCTIONMANAGER, FIELDCONSTRUCTIONMANAGER, RESELLER, USERDEFINED} IfcRoleEnum; +std::string ToString(IfcRoleEnum v); +IfcRoleEnum FromString(const std::string& s);} +namespace IfcRoofTypeEnum {typedef enum {FLAT_ROOF, SHED_ROOF, GABLE_ROOF, HIP_ROOF, HIPPED_GABLE_ROOF, GAMBREL_ROOF, MANSARD_ROOF, BARREL_ROOF, RAINBOW_ROOF, BUTTERFLY_ROOF, PAVILION_ROOF, DOME_ROOF, FREEFORM, NOTDEFINED} IfcRoofTypeEnum; +std::string ToString(IfcRoofTypeEnum v); +IfcRoofTypeEnum FromString(const std::string& s);} +namespace IfcSIPrefix {typedef enum {EXA, PETA, TERA, GIGA, MEGA, KILO, HECTO, DECA, DECI, CENTI, MILLI, MICRO, NANO, PICO, FEMTO, ATTO} IfcSIPrefix; +std::string ToString(IfcSIPrefix v); +IfcSIPrefix FromString(const std::string& s);} +namespace IfcSIUnitName {typedef enum {AMPERE, BECQUEREL, CANDELA, COULOMB, CUBIC_METRE, DEGREE_CELSIUS, FARAD, GRAM, GRAY, HENRY, HERTZ, JOULE, KELVIN, LUMEN, LUX, METRE, MOLE, NEWTON, OHM, PASCAL, RADIAN, SECOND, SIEMENS, SIEVERT, SQUARE_METRE, STERADIAN, TESLA, VOLT, WATT, WEBER} IfcSIUnitName; +std::string ToString(IfcSIUnitName v); +IfcSIUnitName FromString(const std::string& s);} +namespace IfcSanitaryTerminalTypeEnum {typedef enum {BATH, BIDET, CISTERN, SHOWER, SINK, SANITARYFOUNTAIN, TOILETPAN, URINAL, WASHHANDBASIN, WCSEAT, USERDEFINED, NOTDEFINED} IfcSanitaryTerminalTypeEnum; +std::string ToString(IfcSanitaryTerminalTypeEnum v); +IfcSanitaryTerminalTypeEnum FromString(const std::string& s);} +namespace IfcSectionTypeEnum {typedef enum {UNIFORM, TAPERED} IfcSectionTypeEnum; +std::string ToString(IfcSectionTypeEnum v); +IfcSectionTypeEnum FromString(const std::string& s);} +namespace IfcSensorTypeEnum {typedef enum {CO2SENSOR, FIRESENSOR, FLOWSENSOR, GASSENSOR, HEATSENSOR, HUMIDITYSENSOR, LIGHTSENSOR, MOISTURESENSOR, MOVEMENTSENSOR, PRESSURESENSOR, SMOKESENSOR, SOUNDSENSOR, TEMPERATURESENSOR, USERDEFINED, NOTDEFINED} IfcSensorTypeEnum; +std::string ToString(IfcSensorTypeEnum v); +IfcSensorTypeEnum FromString(const std::string& s);} +namespace IfcSequenceEnum {typedef enum {START_START, START_FINISH, FINISH_START, FINISH_FINISH, NOTDEFINED} IfcSequenceEnum; +std::string ToString(IfcSequenceEnum v); +IfcSequenceEnum FromString(const std::string& s);} +namespace IfcServiceLifeFactorTypeEnum {typedef enum {A_QUALITYOFCOMPONENTS, B_DESIGNLEVEL, C_WORKEXECUTIONLEVEL, D_INDOORENVIRONMENT, E_OUTDOORENVIRONMENT, F_INUSECONDITIONS, G_MAINTENANCELEVEL, USERDEFINED, NOTDEFINED} IfcServiceLifeFactorTypeEnum; +std::string ToString(IfcServiceLifeFactorTypeEnum v); +IfcServiceLifeFactorTypeEnum FromString(const std::string& s);} +namespace IfcServiceLifeTypeEnum {typedef enum {ACTUALSERVICELIFE, EXPECTEDSERVICELIFE, OPTIMISTICREFERENCESERVICELIFE, PESSIMISTICREFERENCESERVICELIFE, REFERENCESERVICELIFE} IfcServiceLifeTypeEnum; +std::string ToString(IfcServiceLifeTypeEnum v); +IfcServiceLifeTypeEnum FromString(const std::string& s);} +namespace IfcSlabTypeEnum {typedef enum {FLOOR, ROOF, LANDING, BASESLAB, USERDEFINED, NOTDEFINED} IfcSlabTypeEnum; +std::string ToString(IfcSlabTypeEnum v); +IfcSlabTypeEnum FromString(const std::string& s);} +namespace IfcSoundScaleEnum {typedef enum {DBA, DBB, DBC, NC, NR, USERDEFINED, NOTDEFINED} IfcSoundScaleEnum; +std::string ToString(IfcSoundScaleEnum v); +IfcSoundScaleEnum FromString(const std::string& s);} +namespace IfcSpaceHeaterTypeEnum {typedef enum {SECTIONALRADIATOR, PANELRADIATOR, TUBULARRADIATOR, CONVECTOR, BASEBOARDHEATER, FINNEDTUBEUNIT, UNITHEATER, USERDEFINED, NOTDEFINED} IfcSpaceHeaterTypeEnum; +std::string ToString(IfcSpaceHeaterTypeEnum v); +IfcSpaceHeaterTypeEnum FromString(const std::string& s);} +namespace IfcSpaceTypeEnum {typedef enum {USERDEFINED, NOTDEFINED} IfcSpaceTypeEnum; +std::string ToString(IfcSpaceTypeEnum v); +IfcSpaceTypeEnum FromString(const std::string& s);} +namespace IfcStackTerminalTypeEnum {typedef enum {BIRDCAGE, COWL, RAINWATERHOPPER, USERDEFINED, NOTDEFINED} IfcStackTerminalTypeEnum; +std::string ToString(IfcStackTerminalTypeEnum v); +IfcStackTerminalTypeEnum FromString(const std::string& s);} +namespace IfcStairFlightTypeEnum {typedef enum {STRAIGHT, WINDER, SPIRAL, CURVED, FREEFORM, USERDEFINED, NOTDEFINED} IfcStairFlightTypeEnum; +std::string ToString(IfcStairFlightTypeEnum v); +IfcStairFlightTypeEnum FromString(const std::string& s);} +namespace IfcStairTypeEnum {typedef enum {STRAIGHT_RUN_STAIR, TWO_STRAIGHT_RUN_STAIR, QUARTER_WINDING_STAIR, QUARTER_TURN_STAIR, HALF_WINDING_STAIR, HALF_TURN_STAIR, TWO_QUARTER_WINDING_STAIR, TWO_QUARTER_TURN_STAIR, THREE_QUARTER_WINDING_STAIR, THREE_QUARTER_TURN_STAIR, SPIRAL_STAIR, DOUBLE_RETURN_STAIR, CURVED_RUN_STAIR, TWO_CURVED_RUN_STAIR, USERDEFINED, NOTDEFINED} IfcStairTypeEnum; +std::string ToString(IfcStairTypeEnum v); +IfcStairTypeEnum FromString(const std::string& s);} +namespace IfcStateEnum {typedef enum {READWRITE, READONLY, LOCKED, READWRITELOCKED, READONLYLOCKED} IfcStateEnum; +std::string ToString(IfcStateEnum v); +IfcStateEnum FromString(const std::string& s);} +namespace IfcStructuralCurveTypeEnum {typedef enum {RIGID_JOINED_MEMBER, PIN_JOINED_MEMBER, CABLE, TENSION_MEMBER, COMPRESSION_MEMBER, USERDEFINED, NOTDEFINED} IfcStructuralCurveTypeEnum; +std::string ToString(IfcStructuralCurveTypeEnum v); +IfcStructuralCurveTypeEnum FromString(const std::string& s);} +namespace IfcStructuralSurfaceTypeEnum {typedef enum {BENDING_ELEMENT, MEMBRANE_ELEMENT, SHELL, USERDEFINED, NOTDEFINED} IfcStructuralSurfaceTypeEnum; +std::string ToString(IfcStructuralSurfaceTypeEnum v); +IfcStructuralSurfaceTypeEnum FromString(const std::string& s);} +namespace IfcSurfaceSide {typedef enum {POSITIVE, NEGATIVE, BOTH} IfcSurfaceSide; +std::string ToString(IfcSurfaceSide v); +IfcSurfaceSide FromString(const std::string& s);} +namespace IfcSurfaceTextureEnum {typedef enum {BUMP, OPACITY, REFLECTION, SELFILLUMINATION, SHININESS, SPECULAR, TEXTURE, TRANSPARENCYMAP, NOTDEFINED} IfcSurfaceTextureEnum; +std::string ToString(IfcSurfaceTextureEnum v); +IfcSurfaceTextureEnum FromString(const std::string& s);} +namespace IfcSwitchingDeviceTypeEnum {typedef enum {CONTACTOR, EMERGENCYSTOP, STARTER, SWITCHDISCONNECTOR, TOGGLESWITCH, USERDEFINED, NOTDEFINED} IfcSwitchingDeviceTypeEnum; +std::string ToString(IfcSwitchingDeviceTypeEnum v); +IfcSwitchingDeviceTypeEnum FromString(const std::string& s);} +namespace IfcTankTypeEnum {typedef enum {PREFORMED, SECTIONAL, EXPANSION, PRESSUREVESSEL, USERDEFINED, NOTDEFINED} IfcTankTypeEnum; +std::string ToString(IfcTankTypeEnum v); +IfcTankTypeEnum FromString(const std::string& s);} +namespace IfcTendonTypeEnum {typedef enum {STRAND, WIRE, BAR, COATED, USERDEFINED, NOTDEFINED} IfcTendonTypeEnum; +std::string ToString(IfcTendonTypeEnum v); +IfcTendonTypeEnum FromString(const std::string& s);} +namespace IfcTextPath {typedef enum {LEFT, RIGHT, UP, DOWN} IfcTextPath; +std::string ToString(IfcTextPath v); +IfcTextPath FromString(const std::string& s);} +namespace IfcThermalLoadSourceEnum {typedef enum {PEOPLE, LIGHTING, EQUIPMENT, VENTILATIONINDOORAIR, VENTILATIONOUTSIDEAIR, RECIRCULATEDAIR, EXHAUSTAIR, AIREXCHANGERATE, DRYBULBTEMPERATURE, RELATIVEHUMIDITY, INFILTRATION, USERDEFINED, NOTDEFINED} IfcThermalLoadSourceEnum; +std::string ToString(IfcThermalLoadSourceEnum v); +IfcThermalLoadSourceEnum FromString(const std::string& s);} +namespace IfcThermalLoadTypeEnum {typedef enum {SENSIBLE, LATENT, RADIANT, NOTDEFINED} IfcThermalLoadTypeEnum; +std::string ToString(IfcThermalLoadTypeEnum v); +IfcThermalLoadTypeEnum FromString(const std::string& s);} +namespace IfcTimeSeriesDataTypeEnum {typedef enum {CONTINUOUS, DISCRETE, DISCRETEBINARY, PIECEWISEBINARY, PIECEWISECONSTANT, PIECEWISECONTINUOUS, NOTDEFINED} IfcTimeSeriesDataTypeEnum; +std::string ToString(IfcTimeSeriesDataTypeEnum v); +IfcTimeSeriesDataTypeEnum FromString(const std::string& s);} +namespace IfcTimeSeriesScheduleTypeEnum {typedef enum {ANNUAL, MONTHLY, WEEKLY, DAILY, USERDEFINED, NOTDEFINED} IfcTimeSeriesScheduleTypeEnum; +std::string ToString(IfcTimeSeriesScheduleTypeEnum v); +IfcTimeSeriesScheduleTypeEnum FromString(const std::string& s);} +namespace IfcTransformerTypeEnum {typedef enum {CURRENT, FREQUENCY, VOLTAGE, USERDEFINED, NOTDEFINED} IfcTransformerTypeEnum; +std::string ToString(IfcTransformerTypeEnum v); +IfcTransformerTypeEnum FromString(const std::string& s);} +namespace IfcTransitionCode {typedef enum {DISCONTINUOUS, CONTINUOUS, CONTSAMEGRADIENT, CONTSAMEGRADIENTSAMECURVATURE} IfcTransitionCode; +std::string ToString(IfcTransitionCode v); +IfcTransitionCode FromString(const std::string& s);} +namespace IfcTransportElementTypeEnum {typedef enum {ELEVATOR, ESCALATOR, MOVINGWALKWAY, USERDEFINED, NOTDEFINED} IfcTransportElementTypeEnum; +std::string ToString(IfcTransportElementTypeEnum v); +IfcTransportElementTypeEnum FromString(const std::string& s);} +namespace IfcTrimmingPreference {typedef enum {CARTESIAN, PARAMETER, UNSPECIFIED} IfcTrimmingPreference; +std::string ToString(IfcTrimmingPreference v); +IfcTrimmingPreference FromString(const std::string& s);} +namespace IfcTubeBundleTypeEnum {typedef enum {FINNED, USERDEFINED, NOTDEFINED} IfcTubeBundleTypeEnum; +std::string ToString(IfcTubeBundleTypeEnum v); +IfcTubeBundleTypeEnum FromString(const std::string& s);} +namespace IfcUnitEnum {typedef enum {ABSORBEDDOSEUNIT, AMOUNTOFSUBSTANCEUNIT, AREAUNIT, DOSEEQUIVALENTUNIT, ELECTRICCAPACITANCEUNIT, ELECTRICCHARGEUNIT, ELECTRICCONDUCTANCEUNIT, ELECTRICCURRENTUNIT, ELECTRICRESISTANCEUNIT, ELECTRICVOLTAGEUNIT, ENERGYUNIT, FORCEUNIT, FREQUENCYUNIT, ILLUMINANCEUNIT, INDUCTANCEUNIT, LENGTHUNIT, LUMINOUSFLUXUNIT, LUMINOUSINTENSITYUNIT, MAGNETICFLUXDENSITYUNIT, MAGNETICFLUXUNIT, MASSUNIT, PLANEANGLEUNIT, POWERUNIT, PRESSUREUNIT, RADIOACTIVITYUNIT, SOLIDANGLEUNIT, THERMODYNAMICTEMPERATUREUNIT, TIMEUNIT, VOLUMEUNIT, USERDEFINED} IfcUnitEnum; +std::string ToString(IfcUnitEnum v); +IfcUnitEnum FromString(const std::string& s);} +namespace IfcUnitaryEquipmentTypeEnum {typedef enum {AIRHANDLER, AIRCONDITIONINGUNIT, SPLITSYSTEM, ROOFTOPUNIT, USERDEFINED, NOTDEFINED} IfcUnitaryEquipmentTypeEnum; +std::string ToString(IfcUnitaryEquipmentTypeEnum v); +IfcUnitaryEquipmentTypeEnum FromString(const std::string& s);} +namespace IfcValveTypeEnum {typedef enum {AIRRELEASE, ANTIVACUUM, CHANGEOVER, CHECK, COMMISSIONING, DIVERTING, DRAWOFFCOCK, DOUBLECHECK, DOUBLEREGULATING, FAUCET, FLUSHING, GASCOCK, GASTAP, ISOLATING, MIXING, PRESSUREREDUCING, PRESSURERELIEF, REGULATING, SAFETYCUTOFF, STEAMTRAP, STOPCOCK, USERDEFINED, NOTDEFINED} IfcValveTypeEnum; +std::string ToString(IfcValveTypeEnum v); +IfcValveTypeEnum FromString(const std::string& s);} +namespace IfcVibrationIsolatorTypeEnum {typedef enum {COMPRESSION, SPRING, USERDEFINED, NOTDEFINED} IfcVibrationIsolatorTypeEnum; +std::string ToString(IfcVibrationIsolatorTypeEnum v); +IfcVibrationIsolatorTypeEnum FromString(const std::string& s);} +namespace IfcWallTypeEnum {typedef enum {STANDARD, POLYGONAL, SHEAR, ELEMENTEDWALL, PLUMBINGWALL, USERDEFINED, NOTDEFINED} IfcWallTypeEnum; +std::string ToString(IfcWallTypeEnum v); +IfcWallTypeEnum FromString(const std::string& s);} +namespace IfcWasteTerminalTypeEnum {typedef enum {FLOORTRAP, FLOORWASTE, GULLYSUMP, GULLYTRAP, GREASEINTERCEPTOR, OILINTERCEPTOR, PETROLINTERCEPTOR, ROOFDRAIN, WASTEDISPOSALUNIT, WASTETRAP, USERDEFINED, NOTDEFINED} IfcWasteTerminalTypeEnum; +std::string ToString(IfcWasteTerminalTypeEnum v); +IfcWasteTerminalTypeEnum FromString(const std::string& s);} +namespace IfcWindowPanelOperationEnum {typedef enum {SIDEHUNGRIGHTHAND, SIDEHUNGLEFTHAND, TILTANDTURNRIGHTHAND, TILTANDTURNLEFTHAND, TOPHUNG, BOTTOMHUNG, PIVOTHORIZONTAL, PIVOTVERTICAL, SLIDINGHORIZONTAL, SLIDINGVERTICAL, REMOVABLECASEMENT, FIXEDCASEMENT, OTHEROPERATION, NOTDEFINED} IfcWindowPanelOperationEnum; +std::string ToString(IfcWindowPanelOperationEnum v); +IfcWindowPanelOperationEnum FromString(const std::string& s);} +namespace IfcWindowPanelPositionEnum {typedef enum {LEFT, MIDDLE, RIGHT, BOTTOM, TOP, NOTDEFINED} IfcWindowPanelPositionEnum; +std::string ToString(IfcWindowPanelPositionEnum v); +IfcWindowPanelPositionEnum FromString(const std::string& s);} +namespace IfcWindowStyleConstructionEnum {typedef enum {ALUMINIUM, HIGH_GRADE_STEEL, STEEL, WOOD, ALUMINIUM_WOOD, PLASTIC, OTHER_CONSTRUCTION, NOTDEFINED} IfcWindowStyleConstructionEnum; +std::string ToString(IfcWindowStyleConstructionEnum v); +IfcWindowStyleConstructionEnum FromString(const std::string& s);} +namespace IfcWindowStyleOperationEnum {typedef enum {SINGLE_PANEL, DOUBLE_PANEL_VERTICAL, DOUBLE_PANEL_HORIZONTAL, TRIPLE_PANEL_VERTICAL, TRIPLE_PANEL_BOTTOM, TRIPLE_PANEL_TOP, TRIPLE_PANEL_LEFT, TRIPLE_PANEL_RIGHT, TRIPLE_PANEL_HORIZONTAL, USERDEFINED, NOTDEFINED} IfcWindowStyleOperationEnum; +std::string ToString(IfcWindowStyleOperationEnum v); +IfcWindowStyleOperationEnum FromString(const std::string& s);} +namespace IfcWorkControlTypeEnum {typedef enum {ACTUAL, BASELINE, PLANNED, USERDEFINED, NOTDEFINED} IfcWorkControlTypeEnum; +std::string ToString(IfcWorkControlTypeEnum v); +IfcWorkControlTypeEnum FromString(const std::string& s);} + +// Forward definitions +class Ifc2DCompositeCurve; class IfcActionRequest; class IfcActor; class IfcActorRole; class IfcActuatorType; class IfcAddress; class IfcAirTerminalBoxType; class IfcAirTerminalType; class IfcAirToAirHeatRecoveryType; class IfcAlarmType; class IfcAngularDimension; class IfcAnnotation; class IfcAnnotationCurveOccurrence; class IfcAnnotationFillArea; class IfcAnnotationFillAreaOccurrence; class IfcAnnotationOccurrence; class IfcAnnotationSurface; class IfcAnnotationSurfaceOccurrence; class IfcAnnotationSymbolOccurrence; class IfcAnnotationTextOccurrence; class IfcApplication; class IfcAppliedValue; class IfcAppliedValueRelationship; class IfcApproval; class IfcApprovalActorRelationship; class IfcApprovalPropertyRelationship; class IfcApprovalRelationship; class IfcArbitraryClosedProfileDef; class IfcArbitraryOpenProfileDef; class IfcArbitraryProfileDefWithVoids; class IfcAsset; class IfcAsymmetricIShapeProfileDef; class IfcAxis1Placement; class IfcAxis2Placement2D; class IfcAxis2Placement3D; class IfcBSplineCurve; class IfcBeam; class IfcBeamType; class IfcBezierCurve; class IfcBlobTexture; class IfcBlock; class IfcBoilerType; class IfcBooleanClippingResult; class IfcBooleanResult; class IfcBoundaryCondition; class IfcBoundaryEdgeCondition; class IfcBoundaryFaceCondition; class IfcBoundaryNodeCondition; class IfcBoundaryNodeConditionWarping; class IfcBoundedCurve; class IfcBoundedSurface; class IfcBoundingBox; class IfcBoxedHalfSpace; class IfcBuilding; class IfcBuildingElement; class IfcBuildingElementComponent; class IfcBuildingElementPart; class IfcBuildingElementProxy; class IfcBuildingElementProxyType; class IfcBuildingElementType; class IfcBuildingStorey; class IfcCShapeProfileDef; class IfcCableCarrierFittingType; class IfcCableCarrierSegmentType; class IfcCableSegmentType; class IfcCalendarDate; class IfcCartesianPoint; class IfcCartesianTransformationOperator; class IfcCartesianTransformationOperator2D; class IfcCartesianTransformationOperator2DnonUniform; class IfcCartesianTransformationOperator3D; class IfcCartesianTransformationOperator3DnonUniform; class IfcCenterLineProfileDef; class IfcChamferEdgeFeature; class IfcChillerType; class IfcCircle; class IfcCircleHollowProfileDef; class IfcCircleProfileDef; class IfcClassification; class IfcClassificationItem; class IfcClassificationItemRelationship; class IfcClassificationNotation; class IfcClassificationNotationFacet; class IfcClassificationReference; class IfcClosedShell; class IfcCoilType; class IfcColourRgb; class IfcColourSpecification; class IfcColumn; class IfcColumnType; class IfcComplexProperty; class IfcCompositeCurve; class IfcCompositeCurveSegment; class IfcCompositeProfileDef; class IfcCompressorType; class IfcCondenserType; class IfcCondition; class IfcConditionCriterion; class IfcConic; class IfcConnectedFaceSet; class IfcConnectionCurveGeometry; class IfcConnectionGeometry; class IfcConnectionPointEccentricity; class IfcConnectionPointGeometry; class IfcConnectionPortGeometry; class IfcConnectionSurfaceGeometry; class IfcConstraint; class IfcConstraintAggregationRelationship; class IfcConstraintClassificationRelationship; class IfcConstraintRelationship; class IfcConstructionEquipmentResource; class IfcConstructionMaterialResource; class IfcConstructionProductResource; class IfcConstructionResource; class IfcContextDependentUnit; class IfcControl; class IfcControllerType; class IfcConversionBasedUnit; class IfcCooledBeamType; class IfcCoolingTowerType; class IfcCoordinatedUniversalTimeOffset; class IfcCostItem; class IfcCostSchedule; class IfcCostValue; class IfcCovering; class IfcCoveringType; class IfcCraneRailAShapeProfileDef; class IfcCraneRailFShapeProfileDef; class IfcCrewResource; class IfcCsgPrimitive3D; class IfcCsgSolid; class IfcCurrencyRelationship; class IfcCurtainWall; class IfcCurtainWallType; class IfcCurve; class IfcCurveBoundedPlane; class IfcCurveStyle; class IfcCurveStyleFont; class IfcCurveStyleFontAndScaling; class IfcCurveStyleFontPattern; class IfcDamperType; class IfcDateAndTime; class IfcDefinedSymbol; class IfcDerivedProfileDef; class IfcDerivedUnit; class IfcDerivedUnitElement; class IfcDiameterDimension; class IfcDimensionCalloutRelationship; class IfcDimensionCurve; class IfcDimensionCurveDirectedCallout; class IfcDimensionCurveTerminator; class IfcDimensionPair; class IfcDimensionalExponents; class IfcDirection; class IfcDiscreteAccessory; class IfcDiscreteAccessoryType; class IfcDistributionChamberElement; class IfcDistributionChamberElementType; class IfcDistributionControlElement; class IfcDistributionControlElementType; class IfcDistributionElement; class IfcDistributionElementType; class IfcDistributionFlowElement; class IfcDistributionFlowElementType; class IfcDistributionPort; class IfcDocumentElectronicFormat; class IfcDocumentInformation; class IfcDocumentInformationRelationship; class IfcDocumentReference; class IfcDoor; class IfcDoorLiningProperties; class IfcDoorPanelProperties; class IfcDoorStyle; class IfcDraughtingCallout; class IfcDraughtingCalloutRelationship; class IfcDraughtingPreDefinedColour; class IfcDraughtingPreDefinedCurveFont; class IfcDraughtingPreDefinedTextFont; class IfcDuctFittingType; class IfcDuctSegmentType; class IfcDuctSilencerType; class IfcEdge; class IfcEdgeCurve; class IfcEdgeFeature; class IfcEdgeLoop; class IfcElectricApplianceType; class IfcElectricDistributionPoint; class IfcElectricFlowStorageDeviceType; class IfcElectricGeneratorType; class IfcElectricHeaterType; class IfcElectricMotorType; class IfcElectricTimeControlType; class IfcElectricalBaseProperties; class IfcElectricalCircuit; class IfcElectricalElement; class IfcElement; class IfcElementAssembly; class IfcElementComponent; class IfcElementComponentType; class IfcElementQuantity; class IfcElementType; class IfcElementarySurface; class IfcEllipse; class IfcEllipseProfileDef; class IfcEnergyConversionDevice; class IfcEnergyConversionDeviceType; class IfcEnergyProperties; class IfcEnvironmentalImpactValue; class IfcEquipmentElement; class IfcEquipmentStandard; class IfcEvaporativeCoolerType; class IfcEvaporatorType; class IfcExtendedMaterialProperties; class IfcExternalReference; class IfcExternallyDefinedHatchStyle; class IfcExternallyDefinedSurfaceStyle; class IfcExternallyDefinedSymbol; class IfcExternallyDefinedTextFont; class IfcExtrudedAreaSolid; class IfcFace; class IfcFaceBasedSurfaceModel; class IfcFaceBound; class IfcFaceOuterBound; class IfcFaceSurface; class IfcFacetedBrep; class IfcFacetedBrepWithVoids; class IfcFailureConnectionCondition; class IfcFanType; class IfcFastener; class IfcFastenerType; class IfcFeatureElement; class IfcFeatureElementAddition; class IfcFeatureElementSubtraction; class IfcFillAreaStyle; class IfcFillAreaStyleHatching; class IfcFillAreaStyleTileSymbolWithStyle; class IfcFillAreaStyleTiles; class IfcFilterType; class IfcFireSuppressionTerminalType; class IfcFlowController; class IfcFlowControllerType; class IfcFlowFitting; class IfcFlowFittingType; class IfcFlowInstrumentType; class IfcFlowMeterType; class IfcFlowMovingDevice; class IfcFlowMovingDeviceType; class IfcFlowSegment; class IfcFlowSegmentType; class IfcFlowStorageDevice; class IfcFlowStorageDeviceType; class IfcFlowTerminal; class IfcFlowTerminalType; class IfcFlowTreatmentDevice; class IfcFlowTreatmentDeviceType; class IfcFluidFlowProperties; class IfcFooting; class IfcFuelProperties; class IfcFurnishingElement; class IfcFurnishingElementType; class IfcFurnitureStandard; class IfcFurnitureType; class IfcGasTerminalType; class IfcGeneralMaterialProperties; class IfcGeneralProfileProperties; class IfcGeometricCurveSet; class IfcGeometricRepresentationContext; class IfcGeometricRepresentationItem; class IfcGeometricRepresentationSubContext; class IfcGeometricSet; class IfcGrid; class IfcGridAxis; class IfcGridPlacement; class IfcGroup; class IfcHalfSpaceSolid; class IfcHeatExchangerType; class IfcHumidifierType; class IfcHygroscopicMaterialProperties; class IfcIShapeProfileDef; class IfcImageTexture; class IfcInventory; class IfcIrregularTimeSeries; class IfcIrregularTimeSeriesValue; class IfcJunctionBoxType; class IfcLShapeProfileDef; class IfcLaborResource; class IfcLampType; class IfcLibraryInformation; class IfcLibraryReference; class IfcLightDistributionData; class IfcLightFixtureType; class IfcLightIntensityDistribution; class IfcLightSource; class IfcLightSourceAmbient; class IfcLightSourceDirectional; class IfcLightSourceGoniometric; class IfcLightSourcePositional; class IfcLightSourceSpot; class IfcLine; class IfcLinearDimension; class IfcLocalPlacement; class IfcLocalTime; class IfcLoop; class IfcManifoldSolidBrep; class IfcMappedItem; class IfcMaterial; class IfcMaterialClassificationRelationship; class IfcMaterialDefinitionRepresentation; class IfcMaterialLayer; class IfcMaterialLayerSet; class IfcMaterialLayerSetUsage; class IfcMaterialList; class IfcMaterialProperties; class IfcMeasureWithUnit; class IfcMechanicalConcreteMaterialProperties; class IfcMechanicalFastener; class IfcMechanicalFastenerType; class IfcMechanicalMaterialProperties; class IfcMechanicalSteelMaterialProperties; class IfcMember; class IfcMemberType; class IfcMetric; class IfcMonetaryUnit; class IfcMotorConnectionType; class IfcMove; class IfcNamedUnit; class IfcObject; class IfcObjectDefinition; class IfcObjectPlacement; class IfcObjective; class IfcOccupant; class IfcOffsetCurve2D; class IfcOffsetCurve3D; class IfcOneDirectionRepeatFactor; class IfcOpenShell; class IfcOpeningElement; class IfcOpticalMaterialProperties; class IfcOrderAction; class IfcOrganization; class IfcOrganizationRelationship; class IfcOrientedEdge; class IfcOutletType; class IfcOwnerHistory; class IfcParameterizedProfileDef; class IfcPath; class IfcPerformanceHistory; class IfcPermeableCoveringProperties; class IfcPermit; class IfcPerson; class IfcPersonAndOrganization; class IfcPhysicalComplexQuantity; class IfcPhysicalQuantity; class IfcPhysicalSimpleQuantity; class IfcPile; class IfcPipeFittingType; class IfcPipeSegmentType; class IfcPixelTexture; class IfcPlacement; class IfcPlanarBox; class IfcPlanarExtent; class IfcPlane; class IfcPlate; class IfcPlateType; class IfcPoint; class IfcPointOnCurve; class IfcPointOnSurface; class IfcPolyLoop; class IfcPolygonalBoundedHalfSpace; class IfcPolyline; class IfcPort; class IfcPostalAddress; class IfcPreDefinedColour; class IfcPreDefinedCurveFont; class IfcPreDefinedDimensionSymbol; class IfcPreDefinedItem; class IfcPreDefinedPointMarkerSymbol; class IfcPreDefinedSymbol; class IfcPreDefinedTerminatorSymbol; class IfcPreDefinedTextFont; class IfcPresentationLayerAssignment; class IfcPresentationLayerWithStyle; class IfcPresentationStyle; class IfcPresentationStyleAssignment; class IfcProcedure; class IfcProcess; class IfcProduct; class IfcProductDefinitionShape; class IfcProductRepresentation; class IfcProductsOfCombustionProperties; class IfcProfileDef; class IfcProfileProperties; class IfcProject; class IfcProjectOrder; class IfcProjectOrderRecord; class IfcProjectionCurve; class IfcProjectionElement; class IfcProperty; class IfcPropertyBoundedValue; class IfcPropertyConstraintRelationship; class IfcPropertyDefinition; class IfcPropertyDependencyRelationship; class IfcPropertyEnumeratedValue; class IfcPropertyEnumeration; class IfcPropertyListValue; class IfcPropertyReferenceValue; class IfcPropertySet; class IfcPropertySetDefinition; class IfcPropertySingleValue; class IfcPropertyTableValue; class IfcProtectiveDeviceType; class IfcProxy; class IfcPumpType; class IfcQuantityArea; class IfcQuantityCount; class IfcQuantityLength; class IfcQuantityTime; class IfcQuantityVolume; class IfcQuantityWeight; class IfcRadiusDimension; class IfcRailing; class IfcRailingType; class IfcRamp; class IfcRampFlight; class IfcRampFlightType; class IfcRationalBezierCurve; class IfcRectangleHollowProfileDef; class IfcRectangleProfileDef; class IfcRectangularPyramid; class IfcRectangularTrimmedSurface; class IfcReferencesValueDocument; class IfcRegularTimeSeries; class IfcReinforcementBarProperties; class IfcReinforcementDefinitionProperties; class IfcReinforcingBar; class IfcReinforcingElement; class IfcReinforcingMesh; class IfcRelAggregates; class IfcRelAssigns; class IfcRelAssignsTasks; class IfcRelAssignsToActor; class IfcRelAssignsToControl; class IfcRelAssignsToGroup; class IfcRelAssignsToProcess; class IfcRelAssignsToProduct; class IfcRelAssignsToProjectOrder; class IfcRelAssignsToResource; class IfcRelAssociates; class IfcRelAssociatesAppliedValue; class IfcRelAssociatesApproval; class IfcRelAssociatesClassification; class IfcRelAssociatesConstraint; class IfcRelAssociatesDocument; class IfcRelAssociatesLibrary; class IfcRelAssociatesMaterial; class IfcRelAssociatesProfileProperties; class IfcRelConnects; class IfcRelConnectsElements; class IfcRelConnectsPathElements; class IfcRelConnectsPortToElement; class IfcRelConnectsPorts; class IfcRelConnectsStructuralActivity; class IfcRelConnectsStructuralElement; class IfcRelConnectsStructuralMember; class IfcRelConnectsWithEccentricity; class IfcRelConnectsWithRealizingElements; class IfcRelContainedInSpatialStructure; class IfcRelCoversBldgElements; class IfcRelCoversSpaces; class IfcRelDecomposes; class IfcRelDefines; class IfcRelDefinesByProperties; class IfcRelDefinesByType; class IfcRelFillsElement; class IfcRelFlowControlElements; class IfcRelInteractionRequirements; class IfcRelNests; class IfcRelOccupiesSpaces; class IfcRelOverridesProperties; class IfcRelProjectsElement; class IfcRelReferencedInSpatialStructure; class IfcRelSchedulesCostItems; class IfcRelSequence; class IfcRelServicesBuildings; class IfcRelSpaceBoundary; class IfcRelVoidsElement; class IfcRelationship; class IfcRelaxation; class IfcRepresentation; class IfcRepresentationContext; class IfcRepresentationItem; class IfcRepresentationMap; class IfcResource; class IfcRevolvedAreaSolid; class IfcRibPlateProfileProperties; class IfcRightCircularCone; class IfcRightCircularCylinder; class IfcRoof; class IfcRoot; class IfcRoundedEdgeFeature; class IfcRoundedRectangleProfileDef; class IfcSIUnit; class IfcSanitaryTerminalType; class IfcScheduleTimeControl; class IfcSectionProperties; class IfcSectionReinforcementProperties; class IfcSectionedSpine; class IfcSensorType; class IfcServiceLife; class IfcServiceLifeFactor; class IfcShapeAspect; class IfcShapeModel; class IfcShapeRepresentation; class IfcShellBasedSurfaceModel; class IfcSimpleProperty; class IfcSite; class IfcSlab; class IfcSlabType; class IfcSlippageConnectionCondition; class IfcSolidModel; class IfcSoundProperties; class IfcSoundValue; class IfcSpace; class IfcSpaceHeaterType; class IfcSpaceProgram; class IfcSpaceThermalLoadProperties; class IfcSpaceType; class IfcSpatialStructureElement; class IfcSpatialStructureElementType; class IfcSphere; class IfcStackTerminalType; class IfcStair; class IfcStairFlight; class IfcStairFlightType; class IfcStructuralAction; class IfcStructuralActivity; class IfcStructuralAnalysisModel; class IfcStructuralConnection; class IfcStructuralConnectionCondition; class IfcStructuralCurveConnection; class IfcStructuralCurveMember; class IfcStructuralCurveMemberVarying; class IfcStructuralItem; class IfcStructuralLinearAction; class IfcStructuralLinearActionVarying; class IfcStructuralLoad; class IfcStructuralLoadGroup; class IfcStructuralLoadLinearForce; class IfcStructuralLoadPlanarForce; class IfcStructuralLoadSingleDisplacement; class IfcStructuralLoadSingleDisplacementDistortion; class IfcStructuralLoadSingleForce; class IfcStructuralLoadSingleForceWarping; class IfcStructuralLoadStatic; class IfcStructuralLoadTemperature; class IfcStructuralMember; class IfcStructuralPlanarAction; class IfcStructuralPlanarActionVarying; class IfcStructuralPointAction; class IfcStructuralPointConnection; class IfcStructuralPointReaction; class IfcStructuralProfileProperties; class IfcStructuralReaction; class IfcStructuralResultGroup; class IfcStructuralSteelProfileProperties; class IfcStructuralSurfaceConnection; class IfcStructuralSurfaceMember; class IfcStructuralSurfaceMemberVarying; class IfcStructuredDimensionCallout; class IfcStyleModel; class IfcStyledItem; class IfcStyledRepresentation; class IfcSubContractResource; class IfcSubedge; class IfcSurface; class IfcSurfaceCurveSweptAreaSolid; class IfcSurfaceOfLinearExtrusion; class IfcSurfaceOfRevolution; class IfcSurfaceStyle; class IfcSurfaceStyleLighting; class IfcSurfaceStyleRefraction; class IfcSurfaceStyleRendering; class IfcSurfaceStyleShading; class IfcSurfaceStyleWithTextures; class IfcSurfaceTexture; class IfcSweptAreaSolid; class IfcSweptDiskSolid; class IfcSweptSurface; class IfcSwitchingDeviceType; class IfcSymbolStyle; class IfcSystem; class IfcSystemFurnitureElementType; class IfcTShapeProfileDef; class IfcTable; class IfcTableRow; class IfcTankType; class IfcTask; class IfcTelecomAddress; class IfcTendon; class IfcTendonAnchor; class IfcTerminatorSymbol; class IfcTextLiteral; class IfcTextLiteralWithExtent; class IfcTextStyle; class IfcTextStyleFontModel; class IfcTextStyleForDefinedFont; class IfcTextStyleTextModel; class IfcTextStyleWithBoxCharacteristics; class IfcTextureCoordinate; class IfcTextureCoordinateGenerator; class IfcTextureMap; class IfcTextureVertex; class IfcThermalMaterialProperties; class IfcTimeSeries; class IfcTimeSeriesReferenceRelationship; class IfcTimeSeriesSchedule; class IfcTimeSeriesValue; class IfcTopologicalRepresentationItem; class IfcTopologyRepresentation; class IfcTransformerType; class IfcTransportElement; class IfcTransportElementType; class IfcTrapeziumProfileDef; class IfcTrimmedCurve; class IfcTubeBundleType; class IfcTwoDirectionRepeatFactor; class IfcTypeObject; class IfcTypeProduct; class IfcUShapeProfileDef; class IfcUnitAssignment; class IfcUnitaryEquipmentType; class IfcValveType; class IfcVector; class IfcVertex; class IfcVertexBasedTextureMap; class IfcVertexLoop; class IfcVertexPoint; class IfcVibrationIsolatorType; class IfcVirtualElement; class IfcVirtualGridIntersection; class IfcWall; class IfcWallStandardCase; class IfcWallType; class IfcWasteTerminalType; class IfcWaterProperties; class IfcWindow; class IfcWindowLiningProperties; class IfcWindowPanelProperties; class IfcWindowStyle; class IfcWorkControl; class IfcWorkPlan; class IfcWorkSchedule; class IfcZShapeProfileDef; class IfcZone; + +class IfcActorRole : public IfcBaseClass { +public: + IfcRoleEnum::IfcRoleEnum Role(); + bool hasUserDefinedRole(); + IfcLabel UserDefinedRole(); + bool hasDescription(); + IfcText Description(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcActorRole (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAddress : public IfcBaseClass { +public: + bool hasPurpose(); + IfcAddressTypeEnum::IfcAddressTypeEnum Purpose(); + bool hasDescription(); + IfcText Description(); + bool hasUserDefinedPurpose(); + IfcLabel UserDefinedPurpose(); + SHARED_PTR< IfcTemplatedEntityList > OfPerson(); // INVERSE IfcPerson::Addresses + SHARED_PTR< IfcTemplatedEntityList > OfOrganization(); // INVERSE IfcOrganization::Addresses + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAddress (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcApplication : public IfcBaseClass { +public: + SHARED_PTR ApplicationDeveloper(); + IfcLabel Version(); + IfcLabel ApplicationFullName(); + IfcIdentifier ApplicationIdentifier(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcApplication (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAppliedValue : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + bool hasAppliedValue(); + IfcAppliedValueSelect AppliedValue(); + bool hasUnitBasis(); + SHARED_PTR UnitBasis(); + bool hasApplicableDate(); + IfcDateTimeSelect ApplicableDate(); + bool hasFixedUntilDate(); + IfcDateTimeSelect FixedUntilDate(); + SHARED_PTR< IfcTemplatedEntityList > ValuesReferenced(); // INVERSE IfcReferencesValueDocument::ReferencingValues + SHARED_PTR< IfcTemplatedEntityList > ValueOfComponents(); // INVERSE IfcAppliedValueRelationship::ComponentOfTotal + SHARED_PTR< IfcTemplatedEntityList > IsComponentIn(); // INVERSE IfcAppliedValueRelationship::Components + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAppliedValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAppliedValueRelationship : public IfcBaseClass { +public: + SHARED_PTR ComponentOfTotal(); + SHARED_PTR< IfcTemplatedEntityList > Components(); + IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum ArithmeticOperator(); + bool hasName(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAppliedValueRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcApproval : public IfcBaseClass { +public: + bool hasDescription(); + IfcText Description(); + IfcDateTimeSelect ApprovalDateTime(); + bool hasApprovalStatus(); + IfcLabel ApprovalStatus(); + bool hasApprovalLevel(); + IfcLabel ApprovalLevel(); + bool hasApprovalQualifier(); + IfcText ApprovalQualifier(); + IfcLabel Name(); + IfcIdentifier Identifier(); + SHARED_PTR< IfcTemplatedEntityList > Actors(); // INVERSE IfcApprovalActorRelationship::Approval + SHARED_PTR< IfcTemplatedEntityList > IsRelatedWith(); // INVERSE IfcApprovalRelationship::RelatedApproval + SHARED_PTR< IfcTemplatedEntityList > Relates(); // INVERSE IfcApprovalRelationship::RelatingApproval + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcApproval (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcApprovalActorRelationship : public IfcBaseClass { +public: + IfcActorSelect Actor(); + SHARED_PTR Approval(); + SHARED_PTR Role(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcApprovalActorRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcApprovalPropertyRelationship : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > ApprovedProperties(); + SHARED_PTR Approval(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcApprovalPropertyRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcApprovalRelationship : public IfcBaseClass { +public: + SHARED_PTR RelatedApproval(); + SHARED_PTR RelatingApproval(); + bool hasDescription(); + IfcText Description(); + IfcLabel Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcApprovalRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBoundaryCondition : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBoundaryCondition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBoundaryEdgeCondition : public IfcBoundaryCondition { +public: + bool hasLinearStiffnessByLengthX(); + IfcModulusOfLinearSubgradeReactionMeasure LinearStiffnessByLengthX(); + bool hasLinearStiffnessByLengthY(); + IfcModulusOfLinearSubgradeReactionMeasure LinearStiffnessByLengthY(); + bool hasLinearStiffnessByLengthZ(); + IfcModulusOfLinearSubgradeReactionMeasure LinearStiffnessByLengthZ(); + bool hasRotationalStiffnessByLengthX(); + IfcModulusOfRotationalSubgradeReactionMeasure RotationalStiffnessByLengthX(); + bool hasRotationalStiffnessByLengthY(); + IfcModulusOfRotationalSubgradeReactionMeasure RotationalStiffnessByLengthY(); + bool hasRotationalStiffnessByLengthZ(); + IfcModulusOfRotationalSubgradeReactionMeasure RotationalStiffnessByLengthZ(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBoundaryEdgeCondition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBoundaryFaceCondition : public IfcBoundaryCondition { +public: + bool hasLinearStiffnessByAreaX(); + IfcModulusOfSubgradeReactionMeasure LinearStiffnessByAreaX(); + bool hasLinearStiffnessByAreaY(); + IfcModulusOfSubgradeReactionMeasure LinearStiffnessByAreaY(); + bool hasLinearStiffnessByAreaZ(); + IfcModulusOfSubgradeReactionMeasure LinearStiffnessByAreaZ(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBoundaryFaceCondition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBoundaryNodeCondition : public IfcBoundaryCondition { +public: + bool hasLinearStiffnessX(); + IfcLinearStiffnessMeasure LinearStiffnessX(); + bool hasLinearStiffnessY(); + IfcLinearStiffnessMeasure LinearStiffnessY(); + bool hasLinearStiffnessZ(); + IfcLinearStiffnessMeasure LinearStiffnessZ(); + bool hasRotationalStiffnessX(); + IfcRotationalStiffnessMeasure RotationalStiffnessX(); + bool hasRotationalStiffnessY(); + IfcRotationalStiffnessMeasure RotationalStiffnessY(); + bool hasRotationalStiffnessZ(); + IfcRotationalStiffnessMeasure RotationalStiffnessZ(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBoundaryNodeCondition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBoundaryNodeConditionWarping : public IfcBoundaryNodeCondition { +public: + bool hasWarpingStiffness(); + IfcWarpingMomentMeasure WarpingStiffness(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBoundaryNodeConditionWarping (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCalendarDate : public IfcBaseClass { +public: + IfcDayInMonthNumber DayComponent(); + IfcMonthInYearNumber MonthComponent(); + IfcYearNumber YearComponent(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCalendarDate (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcClassification : public IfcBaseClass { +public: + IfcLabel Source(); + IfcLabel Edition(); + bool hasEditionDate(); + SHARED_PTR EditionDate(); + IfcLabel Name(); + SHARED_PTR< IfcTemplatedEntityList > Contains(); // INVERSE IfcClassificationItem::ItemOf + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcClassification (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcClassificationItem : public IfcBaseClass { +public: + SHARED_PTR Notation(); + bool hasItemOf(); + SHARED_PTR ItemOf(); + IfcLabel Title(); + SHARED_PTR< IfcTemplatedEntityList > IsClassifiedItemIn(); // INVERSE IfcClassificationItemRelationship::RelatedItems + SHARED_PTR< IfcTemplatedEntityList > IsClassifyingItemIn(); // INVERSE IfcClassificationItemRelationship::RelatingItem + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcClassificationItem (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcClassificationItemRelationship : public IfcBaseClass { +public: + SHARED_PTR RelatingItem(); + SHARED_PTR< IfcTemplatedEntityList > RelatedItems(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcClassificationItemRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcClassificationNotation : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > NotationFacets(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcClassificationNotation (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcClassificationNotationFacet : public IfcBaseClass { +public: + IfcLabel NotationValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcClassificationNotationFacet (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcColourSpecification : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcColourSpecification (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConnectionGeometry : public IfcBaseClass { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConnectionGeometry (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConnectionPointGeometry : public IfcConnectionGeometry { +public: + IfcPointOrVertexPoint PointOnRelatingElement(); + bool hasPointOnRelatedElement(); + IfcPointOrVertexPoint PointOnRelatedElement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConnectionPointGeometry (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConnectionPortGeometry : public IfcConnectionGeometry { +public: + IfcAxis2Placement LocationAtRelatingElement(); + bool hasLocationAtRelatedElement(); + IfcAxis2Placement LocationAtRelatedElement(); + SHARED_PTR ProfileOfPort(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConnectionPortGeometry (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConnectionSurfaceGeometry : public IfcConnectionGeometry { +public: + IfcSurfaceOrFaceSurface SurfaceOnRelatingElement(); + bool hasSurfaceOnRelatedElement(); + IfcSurfaceOrFaceSurface SurfaceOnRelatedElement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConnectionSurfaceGeometry (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConstraint : public IfcBaseClass { +public: + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + IfcConstraintEnum::IfcConstraintEnum ConstraintGrade(); + bool hasConstraintSource(); + IfcLabel ConstraintSource(); + bool hasCreatingActor(); + IfcActorSelect CreatingActor(); + bool hasCreationTime(); + IfcDateTimeSelect CreationTime(); + bool hasUserDefinedGrade(); + IfcLabel UserDefinedGrade(); + SHARED_PTR< IfcTemplatedEntityList > ClassifiedAs(); // INVERSE IfcConstraintClassificationRelationship::ClassifiedConstraint + SHARED_PTR< IfcTemplatedEntityList > RelatesConstraints(); // INVERSE IfcConstraintRelationship::RelatingConstraint + SHARED_PTR< IfcTemplatedEntityList > IsRelatedWith(); // INVERSE IfcConstraintRelationship::RelatedConstraints + SHARED_PTR< IfcTemplatedEntityList > PropertiesForConstraint(); // INVERSE IfcPropertyConstraintRelationship::RelatingConstraint + SHARED_PTR< IfcTemplatedEntityList > Aggregates(); // INVERSE IfcConstraintAggregationRelationship::RelatingConstraint + SHARED_PTR< IfcTemplatedEntityList > IsAggregatedIn(); // INVERSE IfcConstraintAggregationRelationship::RelatedConstraints + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConstraint (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConstraintAggregationRelationship : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + SHARED_PTR RelatingConstraint(); + SHARED_PTR< IfcTemplatedEntityList > RelatedConstraints(); + IfcLogicalOperatorEnum::IfcLogicalOperatorEnum LogicalAggregator(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConstraintAggregationRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConstraintClassificationRelationship : public IfcBaseClass { +public: + SHARED_PTR ClassifiedConstraint(); + SHARED_PTR< IfcTemplatedEntityList > RelatedClassifications(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConstraintClassificationRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConstraintRelationship : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + SHARED_PTR RelatingConstraint(); + SHARED_PTR< IfcTemplatedEntityList > RelatedConstraints(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConstraintRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCoordinatedUniversalTimeOffset : public IfcBaseClass { +public: + IfcHourInDay HourOffset(); + bool hasMinuteOffset(); + IfcMinuteInHour MinuteOffset(); + IfcAheadOrBehind::IfcAheadOrBehind Sense(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCoordinatedUniversalTimeOffset (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCostValue : public IfcAppliedValue { +public: + IfcLabel CostType(); + bool hasCondition(); + IfcText Condition(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCostValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCurrencyRelationship : public IfcBaseClass { +public: + SHARED_PTR RelatingMonetaryUnit(); + SHARED_PTR RelatedMonetaryUnit(); + IfcPositiveRatioMeasure ExchangeRate(); + SHARED_PTR RateDateTime(); + bool hasRateSource(); + SHARED_PTR RateSource(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCurrencyRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCurveStyleFont : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + SHARED_PTR< IfcTemplatedEntityList > PatternList(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCurveStyleFont (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCurveStyleFontAndScaling : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + IfcCurveStyleFontSelect CurveFont(); + IfcPositiveRatioMeasure CurveFontScaling(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCurveStyleFontAndScaling (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCurveStyleFontPattern : public IfcBaseClass { +public: + IfcLengthMeasure VisibleSegmentLength(); + IfcPositiveLengthMeasure InvisibleSegmentLength(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCurveStyleFontPattern (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDateAndTime : public IfcBaseClass { +public: + SHARED_PTR DateComponent(); + SHARED_PTR TimeComponent(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDateAndTime (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDerivedUnit : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > Elements(); + IfcDerivedUnitEnum::IfcDerivedUnitEnum UnitType(); + bool hasUserDefinedType(); + IfcLabel UserDefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDerivedUnit (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDerivedUnitElement : public IfcBaseClass { +public: + SHARED_PTR Unit(); + int Exponent(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDerivedUnitElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDimensionalExponents : public IfcBaseClass { +public: + int LengthExponent(); + int MassExponent(); + int TimeExponent(); + int ElectricCurrentExponent(); + int ThermodynamicTemperatureExponent(); + int AmountOfSubstanceExponent(); + int LuminousIntensityExponent(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDimensionalExponents (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDocumentElectronicFormat : public IfcBaseClass { +public: + bool hasFileExtension(); + IfcLabel FileExtension(); + bool hasMimeContentType(); + IfcLabel MimeContentType(); + bool hasMimeSubtype(); + IfcLabel MimeSubtype(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDocumentElectronicFormat (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDocumentInformation : public IfcBaseClass { +public: + IfcIdentifier DocumentId(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + bool hasDocumentReferences(); + SHARED_PTR< IfcTemplatedEntityList > DocumentReferences(); + bool hasPurpose(); + IfcText Purpose(); + bool hasIntendedUse(); + IfcText IntendedUse(); + bool hasScope(); + IfcText Scope(); + bool hasRevision(); + IfcLabel Revision(); + bool hasDocumentOwner(); + IfcActorSelect DocumentOwner(); + bool hasEditors(); + SHARED_PTR< IfcTemplatedEntityList > Editors(); + bool hasCreationTime(); + SHARED_PTR CreationTime(); + bool hasLastRevisionTime(); + SHARED_PTR LastRevisionTime(); + bool hasElectronicFormat(); + SHARED_PTR ElectronicFormat(); + bool hasValidFrom(); + SHARED_PTR ValidFrom(); + bool hasValidUntil(); + SHARED_PTR ValidUntil(); + bool hasConfidentiality(); + IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum Confidentiality(); + bool hasStatus(); + IfcDocumentStatusEnum::IfcDocumentStatusEnum Status(); + SHARED_PTR< IfcTemplatedEntityList > IsPointedTo(); // INVERSE IfcDocumentInformationRelationship::RelatedDocuments + SHARED_PTR< IfcTemplatedEntityList > IsPointer(); // INVERSE IfcDocumentInformationRelationship::RelatingDocument + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDocumentInformation (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDocumentInformationRelationship : public IfcBaseClass { +public: + SHARED_PTR RelatingDocument(); + SHARED_PTR< IfcTemplatedEntityList > RelatedDocuments(); + bool hasRelationshipType(); + IfcLabel RelationshipType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDocumentInformationRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDraughtingCalloutRelationship : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + SHARED_PTR RelatingDraughtingCallout(); + SHARED_PTR RelatedDraughtingCallout(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDraughtingCalloutRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEnvironmentalImpactValue : public IfcAppliedValue { +public: + IfcLabel ImpactType(); + IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum Category(); + bool hasUserDefinedCategory(); + IfcLabel UserDefinedCategory(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEnvironmentalImpactValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcExternalReference : public IfcBaseClass { +public: + bool hasLocation(); + IfcLabel Location(); + bool hasItemReference(); + IfcIdentifier ItemReference(); + bool hasName(); + IfcLabel Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcExternalReference (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcExternallyDefinedHatchStyle : public IfcExternalReference { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcExternallyDefinedHatchStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcExternallyDefinedSurfaceStyle : public IfcExternalReference { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcExternallyDefinedSurfaceStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcExternallyDefinedSymbol : public IfcExternalReference { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcExternallyDefinedSymbol (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcExternallyDefinedTextFont : public IfcExternalReference { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcExternallyDefinedTextFont (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGridAxis : public IfcBaseClass { +public: + bool hasAxisTag(); + IfcLabel AxisTag(); + SHARED_PTR AxisCurve(); + IfcBoolean SameSense(); + SHARED_PTR< IfcTemplatedEntityList > PartOfW(); // INVERSE IfcGrid::WAxes + SHARED_PTR< IfcTemplatedEntityList > PartOfV(); // INVERSE IfcGrid::VAxes + SHARED_PTR< IfcTemplatedEntityList > PartOfU(); // INVERSE IfcGrid::UAxes + SHARED_PTR< IfcTemplatedEntityList > HasIntersections(); // INVERSE IfcVirtualGridIntersection::IntersectingAxes + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGridAxis (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcIrregularTimeSeriesValue : public IfcBaseClass { +public: + IfcDateTimeSelect TimeStamp(); + SHARED_PTR< IfcTemplatedEntityList > ListValues(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcIrregularTimeSeriesValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLibraryInformation : public IfcBaseClass { +public: + IfcLabel Name(); + bool hasVersion(); + IfcLabel Version(); + bool hasPublisher(); + SHARED_PTR Publisher(); + bool hasVersionDate(); + SHARED_PTR VersionDate(); + bool hasLibraryReference(); + SHARED_PTR< IfcTemplatedEntityList > LibraryReference(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLibraryInformation (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLibraryReference : public IfcExternalReference { +public: + SHARED_PTR< IfcTemplatedEntityList > ReferenceIntoLibrary(); // INVERSE IfcLibraryInformation::LibraryReference + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLibraryReference (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLightDistributionData : public IfcBaseClass { +public: + IfcPlaneAngleMeasure MainPlaneAngle(); + std::vector SecondaryPlaneAngle(); + std::vector LuminousIntensity(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLightDistributionData (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLightIntensityDistribution : public IfcBaseClass { +public: + IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum LightDistributionCurve(); + SHARED_PTR< IfcTemplatedEntityList > DistributionData(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLightIntensityDistribution (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLocalTime : public IfcBaseClass { +public: + IfcHourInDay HourComponent(); + bool hasMinuteComponent(); + IfcMinuteInHour MinuteComponent(); + bool hasSecondComponent(); + IfcSecondInMinute SecondComponent(); + bool hasZone(); + SHARED_PTR Zone(); + bool hasDaylightSavingOffset(); + IfcDaylightSavingHour DaylightSavingOffset(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLocalTime (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMaterial : public IfcBaseClass { +public: + IfcLabel Name(); + SHARED_PTR< IfcTemplatedEntityList > HasRepresentation(); // INVERSE IfcMaterialDefinitionRepresentation::RepresentedMaterial + SHARED_PTR< IfcTemplatedEntityList > ClassifiedAs(); // INVERSE IfcMaterialClassificationRelationship::ClassifiedMaterial + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMaterial (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMaterialClassificationRelationship : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > MaterialClassifications(); + SHARED_PTR ClassifiedMaterial(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMaterialClassificationRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMaterialLayer : public IfcBaseClass { +public: + bool hasMaterial(); + SHARED_PTR Material(); + IfcPositiveLengthMeasure LayerThickness(); + bool hasIsVentilated(); + IfcLogical IsVentilated(); + SHARED_PTR< IfcTemplatedEntityList > ToMaterialLayerSet(); // INVERSE IfcMaterialLayerSet::MaterialLayers + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMaterialLayer (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMaterialLayerSet : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > MaterialLayers(); + bool hasLayerSetName(); + IfcLabel LayerSetName(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMaterialLayerSet (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMaterialLayerSetUsage : public IfcBaseClass { +public: + SHARED_PTR ForLayerSet(); + IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum LayerSetDirection(); + IfcDirectionSenseEnum::IfcDirectionSenseEnum DirectionSense(); + IfcLengthMeasure OffsetFromReferenceLine(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMaterialLayerSetUsage (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMaterialList : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > Materials(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMaterialList (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMaterialProperties : public IfcBaseClass { +public: + SHARED_PTR Material(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMaterialProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMeasureWithUnit : public IfcBaseClass { +public: + IfcValue ValueComponent(); + IfcUnit UnitComponent(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMeasureWithUnit (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMechanicalMaterialProperties : public IfcMaterialProperties { +public: + bool hasDynamicViscosity(); + IfcDynamicViscosityMeasure DynamicViscosity(); + bool hasYoungModulus(); + IfcModulusOfElasticityMeasure YoungModulus(); + bool hasShearModulus(); + IfcModulusOfElasticityMeasure ShearModulus(); + bool hasPoissonRatio(); + IfcPositiveRatioMeasure PoissonRatio(); + bool hasThermalExpansionCoefficient(); + IfcThermalExpansionCoefficientMeasure ThermalExpansionCoefficient(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMechanicalMaterialProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMechanicalSteelMaterialProperties : public IfcMechanicalMaterialProperties { +public: + bool hasYieldStress(); + IfcPressureMeasure YieldStress(); + bool hasUltimateStress(); + IfcPressureMeasure UltimateStress(); + bool hasUltimateStrain(); + IfcPositiveRatioMeasure UltimateStrain(); + bool hasHardeningModule(); + IfcModulusOfElasticityMeasure HardeningModule(); + bool hasProportionalStress(); + IfcPressureMeasure ProportionalStress(); + bool hasPlasticStrain(); + IfcPositiveRatioMeasure PlasticStrain(); + bool hasRelaxations(); + SHARED_PTR< IfcTemplatedEntityList > Relaxations(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMechanicalSteelMaterialProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMetric : public IfcConstraint { +public: + IfcBenchmarkEnum::IfcBenchmarkEnum Benchmark(); + bool hasValueSource(); + IfcLabel ValueSource(); + IfcMetricValueSelect DataValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMetric (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMonetaryUnit : public IfcBaseClass { +public: + IfcCurrencyEnum::IfcCurrencyEnum Currency(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMonetaryUnit (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcNamedUnit : public IfcBaseClass { +public: + SHARED_PTR Dimensions(); + IfcUnitEnum::IfcUnitEnum UnitType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcNamedUnit (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcObjectPlacement : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > PlacesObject(); // INVERSE IfcProduct::ObjectPlacement + SHARED_PTR< IfcTemplatedEntityList > ReferencedByPlacements(); // INVERSE IfcLocalPlacement::PlacementRelTo + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcObjectPlacement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcObjective : public IfcConstraint { +public: + bool hasBenchmarkValues(); + SHARED_PTR BenchmarkValues(); + bool hasResultValues(); + SHARED_PTR ResultValues(); + IfcObjectiveEnum::IfcObjectiveEnum ObjectiveQualifier(); + bool hasUserDefinedQualifier(); + IfcLabel UserDefinedQualifier(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcObjective (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOpticalMaterialProperties : public IfcMaterialProperties { +public: + bool hasVisibleTransmittance(); + IfcPositiveRatioMeasure VisibleTransmittance(); + bool hasSolarTransmittance(); + IfcPositiveRatioMeasure SolarTransmittance(); + bool hasThermalIrTransmittance(); + IfcPositiveRatioMeasure ThermalIrTransmittance(); + bool hasThermalIrEmissivityBack(); + IfcPositiveRatioMeasure ThermalIrEmissivityBack(); + bool hasThermalIrEmissivityFront(); + IfcPositiveRatioMeasure ThermalIrEmissivityFront(); + bool hasVisibleReflectanceBack(); + IfcPositiveRatioMeasure VisibleReflectanceBack(); + bool hasVisibleReflectanceFront(); + IfcPositiveRatioMeasure VisibleReflectanceFront(); + bool hasSolarReflectanceFront(); + IfcPositiveRatioMeasure SolarReflectanceFront(); + bool hasSolarReflectanceBack(); + IfcPositiveRatioMeasure SolarReflectanceBack(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOpticalMaterialProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOrganization : public IfcBaseClass { +public: + bool hasId(); + IfcIdentifier Id(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + bool hasRoles(); + SHARED_PTR< IfcTemplatedEntityList > Roles(); + bool hasAddresses(); + SHARED_PTR< IfcTemplatedEntityList > Addresses(); + SHARED_PTR< IfcTemplatedEntityList > IsRelatedBy(); // INVERSE IfcOrganizationRelationship::RelatedOrganizations + SHARED_PTR< IfcTemplatedEntityList > Relates(); // INVERSE IfcOrganizationRelationship::RelatingOrganization + SHARED_PTR< IfcTemplatedEntityList > Engages(); // INVERSE IfcPersonAndOrganization::TheOrganization + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOrganization (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOrganizationRelationship : public IfcBaseClass { +public: + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + SHARED_PTR RelatingOrganization(); + SHARED_PTR< IfcTemplatedEntityList > RelatedOrganizations(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOrganizationRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOwnerHistory : public IfcBaseClass { +public: + SHARED_PTR OwningUser(); + SHARED_PTR OwningApplication(); + bool hasState(); + IfcStateEnum::IfcStateEnum State(); + IfcChangeActionEnum::IfcChangeActionEnum ChangeAction(); + bool hasLastModifiedDate(); + IfcTimeStamp LastModifiedDate(); + bool hasLastModifyingUser(); + SHARED_PTR LastModifyingUser(); + bool hasLastModifyingApplication(); + SHARED_PTR LastModifyingApplication(); + IfcTimeStamp CreationDate(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOwnerHistory (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPerson : public IfcBaseClass { +public: + bool hasId(); + IfcIdentifier Id(); + bool hasFamilyName(); + IfcLabel FamilyName(); + bool hasGivenName(); + IfcLabel GivenName(); + bool hasMiddleNames(); + std::vector MiddleNames(); + bool hasPrefixTitles(); + std::vector PrefixTitles(); + bool hasSuffixTitles(); + std::vector SuffixTitles(); + bool hasRoles(); + SHARED_PTR< IfcTemplatedEntityList > Roles(); + bool hasAddresses(); + SHARED_PTR< IfcTemplatedEntityList > Addresses(); + SHARED_PTR< IfcTemplatedEntityList > EngagedIn(); // INVERSE IfcPersonAndOrganization::ThePerson + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPerson (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPersonAndOrganization : public IfcBaseClass { +public: + SHARED_PTR ThePerson(); + SHARED_PTR TheOrganization(); + bool hasRoles(); + SHARED_PTR< IfcTemplatedEntityList > Roles(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPersonAndOrganization (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPhysicalQuantity : public IfcBaseClass { +public: + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + SHARED_PTR< IfcTemplatedEntityList > PartOfComplex(); // INVERSE IfcPhysicalComplexQuantity::HasQuantities + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPhysicalQuantity (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPhysicalSimpleQuantity : public IfcPhysicalQuantity { +public: + bool hasUnit(); + SHARED_PTR Unit(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPhysicalSimpleQuantity (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPostalAddress : public IfcAddress { +public: + bool hasInternalLocation(); + IfcLabel InternalLocation(); + bool hasAddressLines(); + std::vector AddressLines(); + bool hasPostalBox(); + IfcLabel PostalBox(); + bool hasTown(); + IfcLabel Town(); + bool hasRegion(); + IfcLabel Region(); + bool hasPostalCode(); + IfcLabel PostalCode(); + bool hasCountry(); + IfcLabel Country(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPostalAddress (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPreDefinedItem : public IfcBaseClass { +public: + IfcLabel Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPreDefinedItem (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPreDefinedSymbol : public IfcPreDefinedItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPreDefinedSymbol (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPreDefinedTerminatorSymbol : public IfcPreDefinedSymbol { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPreDefinedTerminatorSymbol (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPreDefinedTextFont : public IfcPreDefinedItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPreDefinedTextFont (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPresentationLayerAssignment : public IfcBaseClass { +public: + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + SHARED_PTR< IfcTemplatedEntityList > AssignedItems(); + bool hasIdentifier(); + IfcIdentifier Identifier(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPresentationLayerAssignment (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPresentationLayerWithStyle : public IfcPresentationLayerAssignment { +public: + bool LayerOn(); + bool LayerFrozen(); + bool LayerBlocked(); + SHARED_PTR< IfcTemplatedEntityList > LayerStyles(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPresentationLayerWithStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPresentationStyle : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPresentationStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPresentationStyleAssignment : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > Styles(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPresentationStyleAssignment (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProductRepresentation : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + SHARED_PTR< IfcTemplatedEntityList > Representations(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProductRepresentation (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProductsOfCombustionProperties : public IfcMaterialProperties { +public: + bool hasSpecificHeatCapacity(); + IfcSpecificHeatCapacityMeasure SpecificHeatCapacity(); + bool hasN20Content(); + IfcPositiveRatioMeasure N20Content(); + bool hasCOContent(); + IfcPositiveRatioMeasure COContent(); + bool hasCO2Content(); + IfcPositiveRatioMeasure CO2Content(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProductsOfCombustionProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProfileDef : public IfcBaseClass { +public: + IfcProfileTypeEnum::IfcProfileTypeEnum ProfileType(); + bool hasProfileName(); + IfcLabel ProfileName(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProfileProperties : public IfcBaseClass { +public: + bool hasProfileName(); + IfcLabel ProfileName(); + bool hasProfileDefinition(); + SHARED_PTR ProfileDefinition(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProfileProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProperty : public IfcBaseClass { +public: + IfcIdentifier Name(); + bool hasDescription(); + IfcText Description(); + SHARED_PTR< IfcTemplatedEntityList > PropertyForDependance(); // INVERSE IfcPropertyDependencyRelationship::DependingProperty + SHARED_PTR< IfcTemplatedEntityList > PropertyDependsOn(); // INVERSE IfcPropertyDependencyRelationship::DependantProperty + SHARED_PTR< IfcTemplatedEntityList > PartOfComplex(); // INVERSE IfcComplexProperty::HasProperties + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProperty (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertyConstraintRelationship : public IfcBaseClass { +public: + SHARED_PTR RelatingConstraint(); + SHARED_PTR< IfcTemplatedEntityList > RelatedProperties(); + bool hasName(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertyConstraintRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertyDependencyRelationship : public IfcBaseClass { +public: + SHARED_PTR DependingProperty(); + SHARED_PTR DependantProperty(); + bool hasName(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + bool hasExpression(); + IfcText Expression(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertyDependencyRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertyEnumeration : public IfcBaseClass { +public: + IfcLabel Name(); + SHARED_PTR< IfcTemplatedEntityList > EnumerationValues(); + bool hasUnit(); + IfcUnit Unit(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertyEnumeration (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcQuantityArea : public IfcPhysicalSimpleQuantity { +public: + IfcAreaMeasure AreaValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcQuantityArea (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcQuantityCount : public IfcPhysicalSimpleQuantity { +public: + IfcCountMeasure CountValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcQuantityCount (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcQuantityLength : public IfcPhysicalSimpleQuantity { +public: + IfcLengthMeasure LengthValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcQuantityLength (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcQuantityTime : public IfcPhysicalSimpleQuantity { +public: + IfcTimeMeasure TimeValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcQuantityTime (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcQuantityVolume : public IfcPhysicalSimpleQuantity { +public: + IfcVolumeMeasure VolumeValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcQuantityVolume (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcQuantityWeight : public IfcPhysicalSimpleQuantity { +public: + IfcMassMeasure WeightValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcQuantityWeight (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcReferencesValueDocument : public IfcBaseClass { +public: + IfcDocumentSelect ReferencedDocument(); + SHARED_PTR< IfcTemplatedEntityList > ReferencingValues(); + bool hasName(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcReferencesValueDocument (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcReinforcementBarProperties : public IfcBaseClass { +public: + IfcAreaMeasure TotalCrossSectionArea(); + IfcLabel SteelGrade(); + bool hasBarSurface(); + IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum BarSurface(); + bool hasEffectiveDepth(); + IfcLengthMeasure EffectiveDepth(); + bool hasNominalBarDiameter(); + IfcPositiveLengthMeasure NominalBarDiameter(); + bool hasBarCount(); + IfcCountMeasure BarCount(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcReinforcementBarProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelaxation : public IfcBaseClass { +public: + IfcNormalisedRatioMeasure RelaxationValue(); + IfcNormalisedRatioMeasure InitialStress(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelaxation (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRepresentation : public IfcBaseClass { +public: + SHARED_PTR ContextOfItems(); + bool hasRepresentationIdentifier(); + IfcLabel RepresentationIdentifier(); + bool hasRepresentationType(); + IfcLabel RepresentationType(); + SHARED_PTR< IfcTemplatedEntityList > Items(); + SHARED_PTR< IfcTemplatedEntityList > RepresentationMap(); // INVERSE IfcRepresentationMap::MappedRepresentation + SHARED_PTR< IfcTemplatedEntityList > LayerAssignments(); // INVERSE IfcPresentationLayerAssignment::AssignedItems + SHARED_PTR< IfcTemplatedEntityList > OfProductRepresentation(); // INVERSE IfcProductRepresentation::Representations + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRepresentation (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRepresentationContext : public IfcBaseClass { +public: + bool hasContextIdentifier(); + IfcLabel ContextIdentifier(); + bool hasContextType(); + IfcLabel ContextType(); + SHARED_PTR< IfcTemplatedEntityList > RepresentationsInContext(); // INVERSE IfcRepresentation::ContextOfItems + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRepresentationContext (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRepresentationItem : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > LayerAssignments(); // INVERSE IfcPresentationLayerAssignment::AssignedItems + SHARED_PTR< IfcTemplatedEntityList > StyledByItem(); // INVERSE IfcStyledItem::Item + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRepresentationItem (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRepresentationMap : public IfcBaseClass { +public: + IfcAxis2Placement MappingOrigin(); + SHARED_PTR MappedRepresentation(); + SHARED_PTR< IfcTemplatedEntityList > MapUsage(); // INVERSE IfcMappedItem::MappingSource + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRepresentationMap (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRibPlateProfileProperties : public IfcProfileProperties { +public: + bool hasThickness(); + IfcPositiveLengthMeasure Thickness(); + bool hasRibHeight(); + IfcPositiveLengthMeasure RibHeight(); + bool hasRibWidth(); + IfcPositiveLengthMeasure RibWidth(); + bool hasRibSpacing(); + IfcPositiveLengthMeasure RibSpacing(); + IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum Direction(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRibPlateProfileProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRoot : public IfcBaseClass { +public: + IfcGloballyUniqueId GlobalId(); + SHARED_PTR OwnerHistory(); + bool hasName(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRoot (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSIUnit : public IfcNamedUnit { +public: + bool hasPrefix(); + IfcSIPrefix::IfcSIPrefix Prefix(); + IfcSIUnitName::IfcSIUnitName Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSIUnit (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSectionProperties : public IfcBaseClass { +public: + IfcSectionTypeEnum::IfcSectionTypeEnum SectionType(); + SHARED_PTR StartProfile(); + bool hasEndProfile(); + SHARED_PTR EndProfile(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSectionProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSectionReinforcementProperties : public IfcBaseClass { +public: + IfcLengthMeasure LongitudinalStartPosition(); + IfcLengthMeasure LongitudinalEndPosition(); + bool hasTransversePosition(); + IfcLengthMeasure TransversePosition(); + IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum ReinforcementRole(); + SHARED_PTR SectionDefinition(); + SHARED_PTR< IfcTemplatedEntityList > CrossSectionReinforcementDefinitions(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSectionReinforcementProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcShapeAspect : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > ShapeRepresentations(); + bool hasName(); + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + bool ProductDefinitional(); + SHARED_PTR PartOfProductDefinitionShape(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcShapeAspect (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcShapeModel : public IfcRepresentation { +public: + SHARED_PTR< IfcTemplatedEntityList > OfShapeAspect(); // INVERSE IfcShapeAspect::ShapeRepresentations + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcShapeModel (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcShapeRepresentation : public IfcShapeModel { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcShapeRepresentation (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSimpleProperty : public IfcProperty { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSimpleProperty (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralConnectionCondition : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralConnectionCondition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLoad : public IfcBaseClass { +public: + bool hasName(); + IfcLabel Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLoad (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLoadStatic : public IfcStructuralLoad { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLoadStatic (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLoadTemperature : public IfcStructuralLoadStatic { +public: + bool hasDeltaT_Constant(); + IfcThermodynamicTemperatureMeasure DeltaT_Constant(); + bool hasDeltaT_Y(); + IfcThermodynamicTemperatureMeasure DeltaT_Y(); + bool hasDeltaT_Z(); + IfcThermodynamicTemperatureMeasure DeltaT_Z(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLoadTemperature (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStyleModel : public IfcRepresentation { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStyleModel (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStyledItem : public IfcRepresentationItem { +public: + bool hasItem(); + SHARED_PTR Item(); + SHARED_PTR< IfcTemplatedEntityList > Styles(); + bool hasName(); + IfcLabel Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStyledItem (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStyledRepresentation : public IfcStyleModel { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStyledRepresentation (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSurfaceStyle : public IfcPresentationStyle { +public: + IfcSurfaceSide::IfcSurfaceSide Side(); + SHARED_PTR< IfcTemplatedEntityList > Styles(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSurfaceStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSurfaceStyleLighting : public IfcBaseClass { +public: + SHARED_PTR DiffuseTransmissionColour(); + SHARED_PTR DiffuseReflectionColour(); + SHARED_PTR TransmissionColour(); + SHARED_PTR ReflectanceColour(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSurfaceStyleLighting (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSurfaceStyleRefraction : public IfcBaseClass { +public: + bool hasRefractionIndex(); + IfcReal RefractionIndex(); + bool hasDispersionFactor(); + IfcReal DispersionFactor(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSurfaceStyleRefraction (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSurfaceStyleShading : public IfcBaseClass { +public: + SHARED_PTR SurfaceColour(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSurfaceStyleShading (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSurfaceStyleWithTextures : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > Textures(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSurfaceStyleWithTextures (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSurfaceTexture : public IfcBaseClass { +public: + bool RepeatS(); + bool RepeatT(); + IfcSurfaceTextureEnum::IfcSurfaceTextureEnum TextureType(); + bool hasTextureTransform(); + SHARED_PTR TextureTransform(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSurfaceTexture (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSymbolStyle : public IfcPresentationStyle { +public: + IfcSymbolStyleSelect StyleOfSymbol(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSymbolStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTable : public IfcBaseClass { +public: + std::string Name(); + SHARED_PTR< IfcTemplatedEntityList > Rows(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTable (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTableRow : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > RowCells(); + bool IsHeading(); + SHARED_PTR< IfcTemplatedEntityList > OfTable(); // INVERSE IfcTable::Rows + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTableRow (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTelecomAddress : public IfcAddress { +public: + bool hasTelephoneNumbers(); + std::vector TelephoneNumbers(); + bool hasFacsimileNumbers(); + std::vector FacsimileNumbers(); + bool hasPagerNumber(); + IfcLabel PagerNumber(); + bool hasElectronicMailAddresses(); + std::vector ElectronicMailAddresses(); + bool hasWWWHomePageURL(); + IfcLabel WWWHomePageURL(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTelecomAddress (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTextStyle : public IfcPresentationStyle { +public: + bool hasTextCharacterAppearance(); + IfcCharacterStyleSelect TextCharacterAppearance(); + bool hasTextStyle(); + IfcTextStyleSelect TextStyle(); + IfcTextFontSelect TextFontStyle(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTextStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTextStyleFontModel : public IfcPreDefinedTextFont { +public: + bool hasFontFamily(); + std::vector FontFamily(); + bool hasFontStyle(); + IfcFontStyle FontStyle(); + bool hasFontVariant(); + IfcFontVariant FontVariant(); + bool hasFontWeight(); + IfcFontWeight FontWeight(); + IfcSizeSelect FontSize(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTextStyleFontModel (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTextStyleForDefinedFont : public IfcBaseClass { +public: + IfcColour Colour(); + bool hasBackgroundColour(); + IfcColour BackgroundColour(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTextStyleForDefinedFont (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTextStyleTextModel : public IfcBaseClass { +public: + bool hasTextIndent(); + IfcSizeSelect TextIndent(); + bool hasTextAlign(); + IfcTextAlignment TextAlign(); + bool hasTextDecoration(); + IfcTextDecoration TextDecoration(); + bool hasLetterSpacing(); + IfcSizeSelect LetterSpacing(); + bool hasWordSpacing(); + IfcSizeSelect WordSpacing(); + bool hasTextTransform(); + IfcTextTransformation TextTransform(); + bool hasLineHeight(); + IfcSizeSelect LineHeight(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTextStyleTextModel (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTextStyleWithBoxCharacteristics : public IfcBaseClass { +public: + bool hasBoxHeight(); + IfcPositiveLengthMeasure BoxHeight(); + bool hasBoxWidth(); + IfcPositiveLengthMeasure BoxWidth(); + bool hasBoxSlantAngle(); + IfcPlaneAngleMeasure BoxSlantAngle(); + bool hasBoxRotateAngle(); + IfcPlaneAngleMeasure BoxRotateAngle(); + bool hasCharacterSpacing(); + IfcSizeSelect CharacterSpacing(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTextStyleWithBoxCharacteristics (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTextureCoordinate : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > AnnotatedSurface(); // INVERSE IfcAnnotationSurface::TextureCoordinates + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTextureCoordinate (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTextureCoordinateGenerator : public IfcTextureCoordinate { +public: + IfcLabel Mode(); + SHARED_PTR< IfcTemplatedEntityList > Parameter(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTextureCoordinateGenerator (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTextureMap : public IfcTextureCoordinate { +public: + SHARED_PTR< IfcTemplatedEntityList > TextureMaps(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTextureMap (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTextureVertex : public IfcBaseClass { +public: + std::vector Coordinates(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTextureVertex (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcThermalMaterialProperties : public IfcMaterialProperties { +public: + bool hasSpecificHeatCapacity(); + IfcSpecificHeatCapacityMeasure SpecificHeatCapacity(); + bool hasBoilingPoint(); + IfcThermodynamicTemperatureMeasure BoilingPoint(); + bool hasFreezingPoint(); + IfcThermodynamicTemperatureMeasure FreezingPoint(); + bool hasThermalConductivity(); + IfcThermalConductivityMeasure ThermalConductivity(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcThermalMaterialProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTimeSeries : public IfcBaseClass { +public: + IfcLabel Name(); + bool hasDescription(); + IfcText Description(); + IfcDateTimeSelect StartTime(); + IfcDateTimeSelect EndTime(); + IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum TimeSeriesDataType(); + IfcDataOriginEnum::IfcDataOriginEnum DataOrigin(); + bool hasUserDefinedDataOrigin(); + IfcLabel UserDefinedDataOrigin(); + bool hasUnit(); + IfcUnit Unit(); + SHARED_PTR< IfcTemplatedEntityList > DocumentedBy(); // INVERSE IfcTimeSeriesReferenceRelationship::ReferencedTimeSeries + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTimeSeries (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTimeSeriesReferenceRelationship : public IfcBaseClass { +public: + SHARED_PTR ReferencedTimeSeries(); + SHARED_PTR< IfcTemplatedEntityList > TimeSeriesReferences(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTimeSeriesReferenceRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTimeSeriesValue : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > ListValues(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTimeSeriesValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTopologicalRepresentationItem : public IfcRepresentationItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTopologicalRepresentationItem (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTopologyRepresentation : public IfcShapeModel { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTopologyRepresentation (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcUnitAssignment : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > Units(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcUnitAssignment (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcVertex : public IfcTopologicalRepresentationItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcVertex (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcVertexBasedTextureMap : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > TextureVertices(); + SHARED_PTR< IfcTemplatedEntityList > TexturePoints(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcVertexBasedTextureMap (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcVertexPoint : public IfcVertex { +public: + SHARED_PTR VertexGeometry(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcVertexPoint (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcVirtualGridIntersection : public IfcBaseClass { +public: + SHARED_PTR< IfcTemplatedEntityList > IntersectingAxes(); + std::vector OffsetDistances(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcVirtualGridIntersection (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWaterProperties : public IfcMaterialProperties { +public: + bool hasIsPotable(); + bool IsPotable(); + bool hasHardness(); + IfcIonConcentrationMeasure Hardness(); + bool hasAlkalinityConcentration(); + IfcIonConcentrationMeasure AlkalinityConcentration(); + bool hasAcidityConcentration(); + IfcIonConcentrationMeasure AcidityConcentration(); + bool hasImpuritiesContent(); + IfcNormalisedRatioMeasure ImpuritiesContent(); + bool hasPHLevel(); + IfcPHMeasure PHLevel(); + bool hasDissolvedSolidsContent(); + IfcNormalisedRatioMeasure DissolvedSolidsContent(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWaterProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAnnotationOccurrence : public IfcStyledItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAnnotationOccurrence (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAnnotationSurfaceOccurrence : public IfcAnnotationOccurrence { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAnnotationSurfaceOccurrence (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAnnotationSymbolOccurrence : public IfcAnnotationOccurrence { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAnnotationSymbolOccurrence (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAnnotationTextOccurrence : public IfcAnnotationOccurrence { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAnnotationTextOccurrence (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcArbitraryClosedProfileDef : public IfcProfileDef { +public: + SHARED_PTR OuterCurve(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcArbitraryClosedProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcArbitraryOpenProfileDef : public IfcProfileDef { +public: + SHARED_PTR Curve(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcArbitraryOpenProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcArbitraryProfileDefWithVoids : public IfcArbitraryClosedProfileDef { +public: + SHARED_PTR< IfcTemplatedEntityList > InnerCurves(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcArbitraryProfileDefWithVoids (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBlobTexture : public IfcSurfaceTexture { +public: + IfcIdentifier RasterFormat(); + bool RasterCode(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBlobTexture (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCenterLineProfileDef : public IfcArbitraryOpenProfileDef { +public: + IfcPositiveLengthMeasure Thickness(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCenterLineProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcClassificationReference : public IfcExternalReference { +public: + bool hasReferencedSource(); + SHARED_PTR ReferencedSource(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcClassificationReference (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcColourRgb : public IfcColourSpecification { +public: + IfcNormalisedRatioMeasure Red(); + IfcNormalisedRatioMeasure Green(); + IfcNormalisedRatioMeasure Blue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcColourRgb (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcComplexProperty : public IfcProperty { +public: + IfcIdentifier UsageName(); + SHARED_PTR< IfcTemplatedEntityList > HasProperties(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcComplexProperty (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCompositeProfileDef : public IfcProfileDef { +public: + SHARED_PTR< IfcTemplatedEntityList > Profiles(); + bool hasLabel(); + IfcLabel Label(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCompositeProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConnectedFaceSet : public IfcTopologicalRepresentationItem { +public: + SHARED_PTR< IfcTemplatedEntityList > CfsFaces(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConnectedFaceSet (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConnectionCurveGeometry : public IfcConnectionGeometry { +public: + IfcCurveOrEdgeCurve CurveOnRelatingElement(); + bool hasCurveOnRelatedElement(); + IfcCurveOrEdgeCurve CurveOnRelatedElement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConnectionCurveGeometry (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConnectionPointEccentricity : public IfcConnectionPointGeometry { +public: + bool hasEccentricityInX(); + IfcLengthMeasure EccentricityInX(); + bool hasEccentricityInY(); + IfcLengthMeasure EccentricityInY(); + bool hasEccentricityInZ(); + IfcLengthMeasure EccentricityInZ(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConnectionPointEccentricity (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcContextDependentUnit : public IfcNamedUnit { +public: + IfcLabel Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcContextDependentUnit (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConversionBasedUnit : public IfcNamedUnit { +public: + IfcLabel Name(); + SHARED_PTR ConversionFactor(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConversionBasedUnit (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCurveStyle : public IfcPresentationStyle { +public: + bool hasCurveFont(); + IfcCurveFontOrScaledCurveFontSelect CurveFont(); + bool hasCurveWidth(); + IfcSizeSelect CurveWidth(); + bool hasCurveColour(); + IfcColour CurveColour(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCurveStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDerivedProfileDef : public IfcProfileDef { +public: + SHARED_PTR ParentProfile(); + SHARED_PTR Operator(); + bool hasLabel(); + IfcLabel Label(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDerivedProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDimensionCalloutRelationship : public IfcDraughtingCalloutRelationship { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDimensionCalloutRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDimensionPair : public IfcDraughtingCalloutRelationship { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDimensionPair (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDocumentReference : public IfcExternalReference { +public: + SHARED_PTR< IfcTemplatedEntityList > ReferenceToDocument(); // INVERSE IfcDocumentInformation::DocumentReferences + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDocumentReference (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDraughtingPreDefinedTextFont : public IfcPreDefinedTextFont { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDraughtingPreDefinedTextFont (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEdge : public IfcTopologicalRepresentationItem { +public: + SHARED_PTR EdgeStart(); + SHARED_PTR EdgeEnd(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEdge (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEdgeCurve : public IfcEdge { +public: + SHARED_PTR EdgeGeometry(); + bool SameSense(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEdgeCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcExtendedMaterialProperties : public IfcMaterialProperties { +public: + SHARED_PTR< IfcTemplatedEntityList > ExtendedProperties(); + bool hasDescription(); + IfcText Description(); + IfcLabel Name(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcExtendedMaterialProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFace : public IfcTopologicalRepresentationItem { +public: + SHARED_PTR< IfcTemplatedEntityList > Bounds(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFace (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFaceBound : public IfcTopologicalRepresentationItem { +public: + SHARED_PTR Bound(); + bool Orientation(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFaceBound (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFaceOuterBound : public IfcFaceBound { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFaceOuterBound (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFaceSurface : public IfcFace { +public: + SHARED_PTR FaceSurface(); + bool SameSense(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFaceSurface (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFailureConnectionCondition : public IfcStructuralConnectionCondition { +public: + bool hasTensionFailureX(); + IfcForceMeasure TensionFailureX(); + bool hasTensionFailureY(); + IfcForceMeasure TensionFailureY(); + bool hasTensionFailureZ(); + IfcForceMeasure TensionFailureZ(); + bool hasCompressionFailureX(); + IfcForceMeasure CompressionFailureX(); + bool hasCompressionFailureY(); + IfcForceMeasure CompressionFailureY(); + bool hasCompressionFailureZ(); + IfcForceMeasure CompressionFailureZ(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFailureConnectionCondition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFillAreaStyle : public IfcPresentationStyle { +public: + SHARED_PTR< IfcTemplatedEntityList > FillStyles(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFillAreaStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFuelProperties : public IfcMaterialProperties { +public: + bool hasCombustionTemperature(); + IfcThermodynamicTemperatureMeasure CombustionTemperature(); + bool hasCarbonContent(); + IfcPositiveRatioMeasure CarbonContent(); + bool hasLowerHeatingValue(); + IfcHeatingValueMeasure LowerHeatingValue(); + bool hasHigherHeatingValue(); + IfcHeatingValueMeasure HigherHeatingValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFuelProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGeneralMaterialProperties : public IfcMaterialProperties { +public: + bool hasMolecularWeight(); + IfcMolecularWeightMeasure MolecularWeight(); + bool hasPorosity(); + IfcNormalisedRatioMeasure Porosity(); + bool hasMassDensity(); + IfcMassDensityMeasure MassDensity(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGeneralMaterialProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGeneralProfileProperties : public IfcProfileProperties { +public: + bool hasPhysicalWeight(); + IfcMassPerLengthMeasure PhysicalWeight(); + bool hasPerimeter(); + IfcPositiveLengthMeasure Perimeter(); + bool hasMinimumPlateThickness(); + IfcPositiveLengthMeasure MinimumPlateThickness(); + bool hasMaximumPlateThickness(); + IfcPositiveLengthMeasure MaximumPlateThickness(); + bool hasCrossSectionArea(); + IfcAreaMeasure CrossSectionArea(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGeneralProfileProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGeometricRepresentationContext : public IfcRepresentationContext { +public: + IfcDimensionCount CoordinateSpaceDimension(); + bool hasPrecision(); + float Precision(); + IfcAxis2Placement WorldCoordinateSystem(); + bool hasTrueNorth(); + SHARED_PTR TrueNorth(); + SHARED_PTR< IfcTemplatedEntityList > HasSubContexts(); // INVERSE IfcGeometricRepresentationSubContext::ParentContext + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGeometricRepresentationContext (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGeometricRepresentationItem : public IfcRepresentationItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGeometricRepresentationItem (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGeometricRepresentationSubContext : public IfcGeometricRepresentationContext { +public: + SHARED_PTR ParentContext(); + bool hasTargetScale(); + IfcPositiveRatioMeasure TargetScale(); + IfcGeometricProjectionEnum::IfcGeometricProjectionEnum TargetView(); + bool hasUserDefinedTargetView(); + IfcLabel UserDefinedTargetView(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGeometricRepresentationSubContext (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGeometricSet : public IfcGeometricRepresentationItem { +public: + SHARED_PTR< IfcTemplatedEntityList > Elements(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGeometricSet (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGridPlacement : public IfcObjectPlacement { +public: + SHARED_PTR PlacementLocation(); + bool hasPlacementRefDirection(); + SHARED_PTR PlacementRefDirection(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGridPlacement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcHalfSpaceSolid : public IfcGeometricRepresentationItem { +public: + SHARED_PTR BaseSurface(); + bool AgreementFlag(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcHalfSpaceSolid (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcHygroscopicMaterialProperties : public IfcMaterialProperties { +public: + bool hasUpperVaporResistanceFactor(); + IfcPositiveRatioMeasure UpperVaporResistanceFactor(); + bool hasLowerVaporResistanceFactor(); + IfcPositiveRatioMeasure LowerVaporResistanceFactor(); + bool hasIsothermalMoistureCapacity(); + IfcIsothermalMoistureCapacityMeasure IsothermalMoistureCapacity(); + bool hasVaporPermeability(); + IfcVaporPermeabilityMeasure VaporPermeability(); + bool hasMoistureDiffusivity(); + IfcMoistureDiffusivityMeasure MoistureDiffusivity(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcHygroscopicMaterialProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcImageTexture : public IfcSurfaceTexture { +public: + IfcIdentifier UrlReference(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcImageTexture (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcIrregularTimeSeries : public IfcTimeSeries { +public: + SHARED_PTR< IfcTemplatedEntityList > Values(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcIrregularTimeSeries (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLightSource : public IfcGeometricRepresentationItem { +public: + bool hasName(); + IfcLabel Name(); + SHARED_PTR LightColour(); + bool hasAmbientIntensity(); + IfcNormalisedRatioMeasure AmbientIntensity(); + bool hasIntensity(); + IfcNormalisedRatioMeasure Intensity(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLightSource (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLightSourceAmbient : public IfcLightSource { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLightSourceAmbient (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLightSourceDirectional : public IfcLightSource { +public: + SHARED_PTR Orientation(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLightSourceDirectional (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLightSourceGoniometric : public IfcLightSource { +public: + SHARED_PTR Position(); + bool hasColourAppearance(); + SHARED_PTR ColourAppearance(); + IfcThermodynamicTemperatureMeasure ColourTemperature(); + IfcLuminousFluxMeasure LuminousFlux(); + IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum LightEmissionSource(); + IfcLightDistributionDataSourceSelect LightDistributionDataSource(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLightSourceGoniometric (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLightSourcePositional : public IfcLightSource { +public: + SHARED_PTR Position(); + IfcPositiveLengthMeasure Radius(); + IfcReal ConstantAttenuation(); + IfcReal DistanceAttenuation(); + IfcReal QuadricAttenuation(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLightSourcePositional (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLightSourceSpot : public IfcLightSourcePositional { +public: + SHARED_PTR Orientation(); + bool hasConcentrationExponent(); + IfcReal ConcentrationExponent(); + IfcPositivePlaneAngleMeasure SpreadAngle(); + IfcPositivePlaneAngleMeasure BeamWidthAngle(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLightSourceSpot (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLocalPlacement : public IfcObjectPlacement { +public: + bool hasPlacementRelTo(); + SHARED_PTR PlacementRelTo(); + IfcAxis2Placement RelativePlacement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLocalPlacement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLoop : public IfcTopologicalRepresentationItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLoop (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMappedItem : public IfcRepresentationItem { +public: + SHARED_PTR MappingSource(); + SHARED_PTR MappingTarget(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMappedItem (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMaterialDefinitionRepresentation : public IfcProductRepresentation { +public: + SHARED_PTR RepresentedMaterial(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMaterialDefinitionRepresentation (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMechanicalConcreteMaterialProperties : public IfcMechanicalMaterialProperties { +public: + bool hasCompressiveStrength(); + IfcPressureMeasure CompressiveStrength(); + bool hasMaxAggregateSize(); + IfcPositiveLengthMeasure MaxAggregateSize(); + bool hasAdmixturesDescription(); + IfcText AdmixturesDescription(); + bool hasWorkability(); + IfcText Workability(); + bool hasProtectivePoreRatio(); + IfcNormalisedRatioMeasure ProtectivePoreRatio(); + bool hasWaterImpermeability(); + IfcText WaterImpermeability(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMechanicalConcreteMaterialProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcObjectDefinition : public IfcRoot { +public: + SHARED_PTR< IfcTemplatedEntityList > HasAssignments(); // INVERSE IfcRelAssigns::RelatedObjects + SHARED_PTR< IfcTemplatedEntityList > IsDecomposedBy(); // INVERSE IfcRelDecomposes::RelatingObject + SHARED_PTR< IfcTemplatedEntityList > Decomposes(); // INVERSE IfcRelDecomposes::RelatedObjects + SHARED_PTR< IfcTemplatedEntityList > HasAssociations(); // INVERSE IfcRelAssociates::RelatedObjects + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcObjectDefinition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOneDirectionRepeatFactor : public IfcGeometricRepresentationItem { +public: + SHARED_PTR RepeatFactor(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOneDirectionRepeatFactor (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOpenShell : public IfcConnectedFaceSet { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOpenShell (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOrientedEdge : public IfcEdge { +public: + SHARED_PTR EdgeElement(); + bool Orientation(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOrientedEdge (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcParameterizedProfileDef : public IfcProfileDef { +public: + SHARED_PTR Position(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcParameterizedProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPath : public IfcTopologicalRepresentationItem { +public: + SHARED_PTR< IfcTemplatedEntityList > EdgeList(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPath (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPhysicalComplexQuantity : public IfcPhysicalQuantity { +public: + SHARED_PTR< IfcTemplatedEntityList > HasQuantities(); + IfcLabel Discrimination(); + bool hasQuality(); + IfcLabel Quality(); + bool hasUsage(); + IfcLabel Usage(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPhysicalComplexQuantity (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPixelTexture : public IfcSurfaceTexture { +public: + IfcInteger Width(); + IfcInteger Height(); + IfcInteger ColourComponents(); + std::vector Pixel(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPixelTexture (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPlacement : public IfcGeometricRepresentationItem { +public: + SHARED_PTR Location(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPlacement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPlanarExtent : public IfcGeometricRepresentationItem { +public: + IfcLengthMeasure SizeInX(); + IfcLengthMeasure SizeInY(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPlanarExtent (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPoint : public IfcGeometricRepresentationItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPoint (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPointOnCurve : public IfcPoint { +public: + SHARED_PTR BasisCurve(); + IfcParameterValue PointParameter(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPointOnCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPointOnSurface : public IfcPoint { +public: + SHARED_PTR BasisSurface(); + IfcParameterValue PointParameterU(); + IfcParameterValue PointParameterV(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPointOnSurface (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPolyLoop : public IfcLoop { +public: + SHARED_PTR< IfcTemplatedEntityList > Polygon(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPolyLoop (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPolygonalBoundedHalfSpace : public IfcHalfSpaceSolid { +public: + SHARED_PTR Position(); + SHARED_PTR PolygonalBoundary(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPolygonalBoundedHalfSpace (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPreDefinedColour : public IfcPreDefinedItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPreDefinedColour (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPreDefinedCurveFont : public IfcPreDefinedItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPreDefinedCurveFont (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPreDefinedDimensionSymbol : public IfcPreDefinedSymbol { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPreDefinedDimensionSymbol (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPreDefinedPointMarkerSymbol : public IfcPreDefinedSymbol { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPreDefinedPointMarkerSymbol (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProductDefinitionShape : public IfcProductRepresentation { +public: + SHARED_PTR< IfcTemplatedEntityList > ShapeOfProduct(); // INVERSE IfcProduct::Representation + SHARED_PTR< IfcTemplatedEntityList > HasShapeAspects(); // INVERSE IfcShapeAspect::PartOfProductDefinitionShape + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProductDefinitionShape (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertyBoundedValue : public IfcSimpleProperty { +public: + bool hasUpperBoundValue(); + IfcValue UpperBoundValue(); + bool hasLowerBoundValue(); + IfcValue LowerBoundValue(); + bool hasUnit(); + IfcUnit Unit(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertyBoundedValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertyDefinition : public IfcRoot { +public: + SHARED_PTR< IfcTemplatedEntityList > HasAssociations(); // INVERSE IfcRelAssociates::RelatedObjects + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertyDefinition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertyEnumeratedValue : public IfcSimpleProperty { +public: + SHARED_PTR< IfcTemplatedEntityList > EnumerationValues(); + bool hasEnumerationReference(); + SHARED_PTR EnumerationReference(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertyEnumeratedValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertyListValue : public IfcSimpleProperty { +public: + SHARED_PTR< IfcTemplatedEntityList > ListValues(); + bool hasUnit(); + IfcUnit Unit(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertyListValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertyReferenceValue : public IfcSimpleProperty { +public: + bool hasUsageName(); + IfcLabel UsageName(); + IfcObjectReferenceSelect PropertyReference(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertyReferenceValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertySetDefinition : public IfcPropertyDefinition { +public: + SHARED_PTR< IfcTemplatedEntityList > PropertyDefinitionOf(); // INVERSE IfcRelDefinesByProperties::RelatingPropertyDefinition + SHARED_PTR< IfcTemplatedEntityList > DefinesType(); // INVERSE IfcTypeObject::HasPropertySets + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertySetDefinition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertySingleValue : public IfcSimpleProperty { +public: + bool hasNominalValue(); + IfcValue NominalValue(); + bool hasUnit(); + IfcUnit Unit(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertySingleValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertyTableValue : public IfcSimpleProperty { +public: + SHARED_PTR< IfcTemplatedEntityList > DefiningValues(); + SHARED_PTR< IfcTemplatedEntityList > DefinedValues(); + bool hasExpression(); + IfcText Expression(); + bool hasDefiningUnit(); + IfcUnit DefiningUnit(); + bool hasDefinedUnit(); + IfcUnit DefinedUnit(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertyTableValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRectangleProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure XDim(); + IfcPositiveLengthMeasure YDim(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRectangleProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRegularTimeSeries : public IfcTimeSeries { +public: + IfcTimeMeasure TimeStep(); + SHARED_PTR< IfcTemplatedEntityList > Values(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRegularTimeSeries (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcReinforcementDefinitionProperties : public IfcPropertySetDefinition { +public: + bool hasDefinitionType(); + IfcLabel DefinitionType(); + SHARED_PTR< IfcTemplatedEntityList > ReinforcementSectionDefinitions(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcReinforcementDefinitionProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelationship : public IfcRoot { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelationship (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRoundedRectangleProfileDef : public IfcRectangleProfileDef { +public: + IfcPositiveLengthMeasure RoundingRadius(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRoundedRectangleProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSectionedSpine : public IfcGeometricRepresentationItem { +public: + SHARED_PTR SpineCurve(); + SHARED_PTR< IfcTemplatedEntityList > CrossSections(); + SHARED_PTR< IfcTemplatedEntityList > CrossSectionPositions(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSectionedSpine (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcServiceLifeFactor : public IfcPropertySetDefinition { +public: + IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum PredefinedType(); + bool hasUpperValue(); + IfcMeasureValue UpperValue(); + IfcMeasureValue MostUsedValue(); + bool hasLowerValue(); + IfcMeasureValue LowerValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcServiceLifeFactor (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcShellBasedSurfaceModel : public IfcGeometricRepresentationItem { +public: + SHARED_PTR< IfcTemplatedEntityList > SbsmBoundary(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcShellBasedSurfaceModel (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSlippageConnectionCondition : public IfcStructuralConnectionCondition { +public: + bool hasSlippageX(); + IfcLengthMeasure SlippageX(); + bool hasSlippageY(); + IfcLengthMeasure SlippageY(); + bool hasSlippageZ(); + IfcLengthMeasure SlippageZ(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSlippageConnectionCondition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSolidModel : public IfcGeometricRepresentationItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSolidModel (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSoundProperties : public IfcPropertySetDefinition { +public: + IfcBoolean IsAttenuating(); + bool hasSoundScale(); + IfcSoundScaleEnum::IfcSoundScaleEnum SoundScale(); + SHARED_PTR< IfcTemplatedEntityList > SoundValues(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSoundProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSoundValue : public IfcPropertySetDefinition { +public: + bool hasSoundLevelTimeSeries(); + SHARED_PTR SoundLevelTimeSeries(); + IfcFrequencyMeasure Frequency(); + bool hasSoundLevelSingleValue(); + IfcDerivedMeasureValue SoundLevelSingleValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSoundValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSpaceThermalLoadProperties : public IfcPropertySetDefinition { +public: + bool hasApplicableValueRatio(); + IfcPositiveRatioMeasure ApplicableValueRatio(); + IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum ThermalLoadSource(); + IfcPropertySourceEnum::IfcPropertySourceEnum PropertySource(); + bool hasSourceDescription(); + IfcText SourceDescription(); + IfcPowerMeasure MaximumValue(); + bool hasMinimumValue(); + IfcPowerMeasure MinimumValue(); + bool hasThermalLoadTimeSeriesValues(); + SHARED_PTR ThermalLoadTimeSeriesValues(); + bool hasUserDefinedThermalLoadSource(); + IfcLabel UserDefinedThermalLoadSource(); + bool hasUserDefinedPropertySource(); + IfcLabel UserDefinedPropertySource(); + IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum ThermalLoadType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSpaceThermalLoadProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLoadLinearForce : public IfcStructuralLoadStatic { +public: + bool hasLinearForceX(); + IfcLinearForceMeasure LinearForceX(); + bool hasLinearForceY(); + IfcLinearForceMeasure LinearForceY(); + bool hasLinearForceZ(); + IfcLinearForceMeasure LinearForceZ(); + bool hasLinearMomentX(); + IfcLinearMomentMeasure LinearMomentX(); + bool hasLinearMomentY(); + IfcLinearMomentMeasure LinearMomentY(); + bool hasLinearMomentZ(); + IfcLinearMomentMeasure LinearMomentZ(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLoadLinearForce (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLoadPlanarForce : public IfcStructuralLoadStatic { +public: + bool hasPlanarForceX(); + IfcPlanarForceMeasure PlanarForceX(); + bool hasPlanarForceY(); + IfcPlanarForceMeasure PlanarForceY(); + bool hasPlanarForceZ(); + IfcPlanarForceMeasure PlanarForceZ(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLoadPlanarForce (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLoadSingleDisplacement : public IfcStructuralLoadStatic { +public: + bool hasDisplacementX(); + IfcLengthMeasure DisplacementX(); + bool hasDisplacementY(); + IfcLengthMeasure DisplacementY(); + bool hasDisplacementZ(); + IfcLengthMeasure DisplacementZ(); + bool hasRotationalDisplacementRX(); + IfcPlaneAngleMeasure RotationalDisplacementRX(); + bool hasRotationalDisplacementRY(); + IfcPlaneAngleMeasure RotationalDisplacementRY(); + bool hasRotationalDisplacementRZ(); + IfcPlaneAngleMeasure RotationalDisplacementRZ(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLoadSingleDisplacement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLoadSingleDisplacementDistortion : public IfcStructuralLoadSingleDisplacement { +public: + bool hasDistortion(); + IfcCurvatureMeasure Distortion(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLoadSingleDisplacementDistortion (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLoadSingleForce : public IfcStructuralLoadStatic { +public: + bool hasForceX(); + IfcForceMeasure ForceX(); + bool hasForceY(); + IfcForceMeasure ForceY(); + bool hasForceZ(); + IfcForceMeasure ForceZ(); + bool hasMomentX(); + IfcTorqueMeasure MomentX(); + bool hasMomentY(); + IfcTorqueMeasure MomentY(); + bool hasMomentZ(); + IfcTorqueMeasure MomentZ(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLoadSingleForce (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLoadSingleForceWarping : public IfcStructuralLoadSingleForce { +public: + bool hasWarpingMoment(); + IfcWarpingMomentMeasure WarpingMoment(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLoadSingleForceWarping (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralProfileProperties : public IfcGeneralProfileProperties { +public: + bool hasTorsionalConstantX(); + IfcMomentOfInertiaMeasure TorsionalConstantX(); + bool hasMomentOfInertiaYZ(); + IfcMomentOfInertiaMeasure MomentOfInertiaYZ(); + bool hasMomentOfInertiaY(); + IfcMomentOfInertiaMeasure MomentOfInertiaY(); + bool hasMomentOfInertiaZ(); + IfcMomentOfInertiaMeasure MomentOfInertiaZ(); + bool hasWarpingConstant(); + IfcWarpingConstantMeasure WarpingConstant(); + bool hasShearCentreZ(); + IfcLengthMeasure ShearCentreZ(); + bool hasShearCentreY(); + IfcLengthMeasure ShearCentreY(); + bool hasShearDeformationAreaZ(); + IfcAreaMeasure ShearDeformationAreaZ(); + bool hasShearDeformationAreaY(); + IfcAreaMeasure ShearDeformationAreaY(); + bool hasMaximumSectionModulusY(); + IfcSectionModulusMeasure MaximumSectionModulusY(); + bool hasMinimumSectionModulusY(); + IfcSectionModulusMeasure MinimumSectionModulusY(); + bool hasMaximumSectionModulusZ(); + IfcSectionModulusMeasure MaximumSectionModulusZ(); + bool hasMinimumSectionModulusZ(); + IfcSectionModulusMeasure MinimumSectionModulusZ(); + bool hasTorsionalSectionModulus(); + IfcSectionModulusMeasure TorsionalSectionModulus(); + bool hasCentreOfGravityInX(); + IfcLengthMeasure CentreOfGravityInX(); + bool hasCentreOfGravityInY(); + IfcLengthMeasure CentreOfGravityInY(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralProfileProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralSteelProfileProperties : public IfcStructuralProfileProperties { +public: + bool hasShearAreaZ(); + IfcAreaMeasure ShearAreaZ(); + bool hasShearAreaY(); + IfcAreaMeasure ShearAreaY(); + bool hasPlasticShapeFactorY(); + IfcPositiveRatioMeasure PlasticShapeFactorY(); + bool hasPlasticShapeFactorZ(); + IfcPositiveRatioMeasure PlasticShapeFactorZ(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralSteelProfileProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSubedge : public IfcEdge { +public: + SHARED_PTR ParentEdge(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSubedge (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSurface : public IfcGeometricRepresentationItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSurface (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSurfaceStyleRendering : public IfcSurfaceStyleShading { +public: + bool hasTransparency(); + IfcNormalisedRatioMeasure Transparency(); + bool hasDiffuseColour(); + IfcColourOrFactor DiffuseColour(); + bool hasTransmissionColour(); + IfcColourOrFactor TransmissionColour(); + bool hasDiffuseTransmissionColour(); + IfcColourOrFactor DiffuseTransmissionColour(); + bool hasReflectionColour(); + IfcColourOrFactor ReflectionColour(); + bool hasSpecularColour(); + IfcColourOrFactor SpecularColour(); + bool hasSpecularHighlight(); + IfcSpecularHighlightSelect SpecularHighlight(); + IfcReflectanceMethodEnum::IfcReflectanceMethodEnum ReflectanceMethod(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSurfaceStyleRendering (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSweptAreaSolid : public IfcSolidModel { +public: + SHARED_PTR SweptArea(); + SHARED_PTR Position(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSweptAreaSolid (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSweptDiskSolid : public IfcSolidModel { +public: + SHARED_PTR Directrix(); + IfcPositiveLengthMeasure Radius(); + bool hasInnerRadius(); + IfcPositiveLengthMeasure InnerRadius(); + IfcParameterValue StartParam(); + IfcParameterValue EndParam(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSweptDiskSolid (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSweptSurface : public IfcSurface { +public: + SHARED_PTR SweptCurve(); + SHARED_PTR Position(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSweptSurface (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTShapeProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure Depth(); + IfcPositiveLengthMeasure FlangeWidth(); + IfcPositiveLengthMeasure WebThickness(); + IfcPositiveLengthMeasure FlangeThickness(); + bool hasFilletRadius(); + IfcPositiveLengthMeasure FilletRadius(); + bool hasFlangeEdgeRadius(); + IfcPositiveLengthMeasure FlangeEdgeRadius(); + bool hasWebEdgeRadius(); + IfcPositiveLengthMeasure WebEdgeRadius(); + bool hasWebSlope(); + IfcPlaneAngleMeasure WebSlope(); + bool hasFlangeSlope(); + IfcPlaneAngleMeasure FlangeSlope(); + bool hasCentreOfGravityInY(); + IfcPositiveLengthMeasure CentreOfGravityInY(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTShapeProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTerminatorSymbol : public IfcAnnotationSymbolOccurrence { +public: + SHARED_PTR AnnotatedCurve(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTerminatorSymbol (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTextLiteral : public IfcGeometricRepresentationItem { +public: + IfcPresentableText Literal(); + IfcAxis2Placement Placement(); + IfcTextPath::IfcTextPath Path(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTextLiteral (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTextLiteralWithExtent : public IfcTextLiteral { +public: + SHARED_PTR Extent(); + IfcBoxAlignment BoxAlignment(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTextLiteralWithExtent (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTrapeziumProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure BottomXDim(); + IfcPositiveLengthMeasure TopXDim(); + IfcPositiveLengthMeasure YDim(); + IfcLengthMeasure TopXOffset(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTrapeziumProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTwoDirectionRepeatFactor : public IfcOneDirectionRepeatFactor { +public: + SHARED_PTR SecondRepeatFactor(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTwoDirectionRepeatFactor (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTypeObject : public IfcObjectDefinition { +public: + bool hasApplicableOccurrence(); + IfcLabel ApplicableOccurrence(); + bool hasHasPropertySets(); + SHARED_PTR< IfcTemplatedEntityList > HasPropertySets(); + SHARED_PTR< IfcTemplatedEntityList > ObjectTypeOf(); // INVERSE IfcRelDefinesByType::RelatingType + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTypeObject (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTypeProduct : public IfcTypeObject { +public: + bool hasRepresentationMaps(); + SHARED_PTR< IfcTemplatedEntityList > RepresentationMaps(); + bool hasTag(); + IfcLabel Tag(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTypeProduct (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcUShapeProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure Depth(); + IfcPositiveLengthMeasure FlangeWidth(); + IfcPositiveLengthMeasure WebThickness(); + IfcPositiveLengthMeasure FlangeThickness(); + bool hasFilletRadius(); + IfcPositiveLengthMeasure FilletRadius(); + bool hasEdgeRadius(); + IfcPositiveLengthMeasure EdgeRadius(); + bool hasFlangeSlope(); + IfcPlaneAngleMeasure FlangeSlope(); + bool hasCentreOfGravityInX(); + IfcPositiveLengthMeasure CentreOfGravityInX(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcUShapeProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcVector : public IfcGeometricRepresentationItem { +public: + SHARED_PTR Orientation(); + IfcLengthMeasure Magnitude(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcVector (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcVertexLoop : public IfcLoop { +public: + SHARED_PTR LoopVertex(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcVertexLoop (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWindowLiningProperties : public IfcPropertySetDefinition { +public: + bool hasLiningDepth(); + IfcPositiveLengthMeasure LiningDepth(); + bool hasLiningThickness(); + IfcPositiveLengthMeasure LiningThickness(); + bool hasTransomThickness(); + IfcPositiveLengthMeasure TransomThickness(); + bool hasMullionThickness(); + IfcPositiveLengthMeasure MullionThickness(); + bool hasFirstTransomOffset(); + IfcNormalisedRatioMeasure FirstTransomOffset(); + bool hasSecondTransomOffset(); + IfcNormalisedRatioMeasure SecondTransomOffset(); + bool hasFirstMullionOffset(); + IfcNormalisedRatioMeasure FirstMullionOffset(); + bool hasSecondMullionOffset(); + IfcNormalisedRatioMeasure SecondMullionOffset(); + bool hasShapeAspectStyle(); + SHARED_PTR ShapeAspectStyle(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWindowLiningProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWindowPanelProperties : public IfcPropertySetDefinition { +public: + IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum OperationType(); + IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum PanelPosition(); + bool hasFrameDepth(); + IfcPositiveLengthMeasure FrameDepth(); + bool hasFrameThickness(); + IfcPositiveLengthMeasure FrameThickness(); + bool hasShapeAspectStyle(); + SHARED_PTR ShapeAspectStyle(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWindowPanelProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWindowStyle : public IfcTypeProduct { +public: + IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum ConstructionType(); + IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum OperationType(); + bool ParameterTakesPrecedence(); + bool Sizeable(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWindowStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcZShapeProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure Depth(); + IfcPositiveLengthMeasure FlangeWidth(); + IfcPositiveLengthMeasure WebThickness(); + IfcPositiveLengthMeasure FlangeThickness(); + bool hasFilletRadius(); + IfcPositiveLengthMeasure FilletRadius(); + bool hasEdgeRadius(); + IfcPositiveLengthMeasure EdgeRadius(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcZShapeProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAnnotationCurveOccurrence : public IfcAnnotationOccurrence { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAnnotationCurveOccurrence (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAnnotationFillArea : public IfcGeometricRepresentationItem { +public: + SHARED_PTR OuterBoundary(); + bool hasInnerBoundaries(); + SHARED_PTR< IfcTemplatedEntityList > InnerBoundaries(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAnnotationFillArea (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAnnotationFillAreaOccurrence : public IfcAnnotationOccurrence { +public: + bool hasFillStyleTarget(); + SHARED_PTR FillStyleTarget(); + bool hasGlobalOrLocal(); + IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum GlobalOrLocal(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAnnotationFillAreaOccurrence (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAnnotationSurface : public IfcGeometricRepresentationItem { +public: + SHARED_PTR Item(); + bool hasTextureCoordinates(); + SHARED_PTR TextureCoordinates(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAnnotationSurface (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAxis1Placement : public IfcPlacement { +public: + bool hasAxis(); + SHARED_PTR Axis(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAxis1Placement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAxis2Placement2D : public IfcPlacement { +public: + bool hasRefDirection(); + SHARED_PTR RefDirection(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAxis2Placement2D (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAxis2Placement3D : public IfcPlacement { +public: + bool hasAxis(); + SHARED_PTR Axis(); + bool hasRefDirection(); + SHARED_PTR RefDirection(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAxis2Placement3D (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBooleanResult : public IfcGeometricRepresentationItem { +public: + IfcBooleanOperator::IfcBooleanOperator Operator(); + IfcBooleanOperand FirstOperand(); + IfcBooleanOperand SecondOperand(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBooleanResult (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBoundedSurface : public IfcSurface { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBoundedSurface (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBoundingBox : public IfcGeometricRepresentationItem { +public: + SHARED_PTR Corner(); + IfcPositiveLengthMeasure XDim(); + IfcPositiveLengthMeasure YDim(); + IfcPositiveLengthMeasure ZDim(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBoundingBox (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBoxedHalfSpace : public IfcHalfSpaceSolid { +public: + SHARED_PTR Enclosure(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBoxedHalfSpace (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCShapeProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure Depth(); + IfcPositiveLengthMeasure Width(); + IfcPositiveLengthMeasure WallThickness(); + IfcPositiveLengthMeasure Girth(); + bool hasInternalFilletRadius(); + IfcPositiveLengthMeasure InternalFilletRadius(); + bool hasCentreOfGravityInX(); + IfcPositiveLengthMeasure CentreOfGravityInX(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCShapeProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCartesianPoint : public IfcPoint { +public: + std::vector Coordinates(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCartesianPoint (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCartesianTransformationOperator : public IfcGeometricRepresentationItem { +public: + bool hasAxis1(); + SHARED_PTR Axis1(); + bool hasAxis2(); + SHARED_PTR Axis2(); + SHARED_PTR LocalOrigin(); + bool hasScale(); + float Scale(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCartesianTransformationOperator (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCartesianTransformationOperator2D : public IfcCartesianTransformationOperator { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCartesianTransformationOperator2D (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCartesianTransformationOperator2DnonUniform : public IfcCartesianTransformationOperator2D { +public: + bool hasScale2(); + float Scale2(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCartesianTransformationOperator2DnonUniform (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCartesianTransformationOperator3D : public IfcCartesianTransformationOperator { +public: + bool hasAxis3(); + SHARED_PTR Axis3(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCartesianTransformationOperator3D (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCartesianTransformationOperator3DnonUniform : public IfcCartesianTransformationOperator3D { +public: + bool hasScale2(); + float Scale2(); + bool hasScale3(); + float Scale3(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCartesianTransformationOperator3DnonUniform (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCircleProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure Radius(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCircleProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcClosedShell : public IfcConnectedFaceSet { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcClosedShell (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCompositeCurveSegment : public IfcGeometricRepresentationItem { +public: + IfcTransitionCode::IfcTransitionCode Transition(); + bool SameSense(); + SHARED_PTR ParentCurve(); + SHARED_PTR< IfcTemplatedEntityList > UsingCurves(); // INVERSE IfcCompositeCurve::Segments + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCompositeCurveSegment (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCraneRailAShapeProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure OverallHeight(); + IfcPositiveLengthMeasure BaseWidth2(); + bool hasRadius(); + IfcPositiveLengthMeasure Radius(); + IfcPositiveLengthMeasure HeadWidth(); + IfcPositiveLengthMeasure HeadDepth2(); + IfcPositiveLengthMeasure HeadDepth3(); + IfcPositiveLengthMeasure WebThickness(); + IfcPositiveLengthMeasure BaseWidth4(); + IfcPositiveLengthMeasure BaseDepth1(); + IfcPositiveLengthMeasure BaseDepth2(); + IfcPositiveLengthMeasure BaseDepth3(); + bool hasCentreOfGravityInY(); + IfcPositiveLengthMeasure CentreOfGravityInY(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCraneRailAShapeProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCraneRailFShapeProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure OverallHeight(); + IfcPositiveLengthMeasure HeadWidth(); + bool hasRadius(); + IfcPositiveLengthMeasure Radius(); + IfcPositiveLengthMeasure HeadDepth2(); + IfcPositiveLengthMeasure HeadDepth3(); + IfcPositiveLengthMeasure WebThickness(); + IfcPositiveLengthMeasure BaseDepth1(); + IfcPositiveLengthMeasure BaseDepth2(); + bool hasCentreOfGravityInY(); + IfcPositiveLengthMeasure CentreOfGravityInY(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCraneRailFShapeProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCsgPrimitive3D : public IfcGeometricRepresentationItem { +public: + SHARED_PTR Position(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCsgPrimitive3D (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCsgSolid : public IfcSolidModel { +public: + IfcCsgSelect TreeRootExpression(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCsgSolid (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCurve : public IfcGeometricRepresentationItem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCurveBoundedPlane : public IfcBoundedSurface { +public: + SHARED_PTR BasisSurface(); + SHARED_PTR OuterBoundary(); + SHARED_PTR< IfcTemplatedEntityList > InnerBoundaries(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCurveBoundedPlane (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDefinedSymbol : public IfcGeometricRepresentationItem { +public: + IfcDefinedSymbolSelect Definition(); + SHARED_PTR Target(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDefinedSymbol (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDimensionCurve : public IfcAnnotationCurveOccurrence { +public: + SHARED_PTR< IfcTemplatedEntityList > AnnotatedBySymbols(); // INVERSE IfcTerminatorSymbol::AnnotatedCurve + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDimensionCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDimensionCurveTerminator : public IfcTerminatorSymbol { +public: + IfcDimensionExtentUsage::IfcDimensionExtentUsage Role(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDimensionCurveTerminator (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDirection : public IfcGeometricRepresentationItem { +public: + std::vector DirectionRatios(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDirection (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDoorLiningProperties : public IfcPropertySetDefinition { +public: + bool hasLiningDepth(); + IfcPositiveLengthMeasure LiningDepth(); + bool hasLiningThickness(); + IfcPositiveLengthMeasure LiningThickness(); + bool hasThresholdDepth(); + IfcPositiveLengthMeasure ThresholdDepth(); + bool hasThresholdThickness(); + IfcPositiveLengthMeasure ThresholdThickness(); + bool hasTransomThickness(); + IfcPositiveLengthMeasure TransomThickness(); + bool hasTransomOffset(); + IfcLengthMeasure TransomOffset(); + bool hasLiningOffset(); + IfcLengthMeasure LiningOffset(); + bool hasThresholdOffset(); + IfcLengthMeasure ThresholdOffset(); + bool hasCasingThickness(); + IfcPositiveLengthMeasure CasingThickness(); + bool hasCasingDepth(); + IfcPositiveLengthMeasure CasingDepth(); + bool hasShapeAspectStyle(); + SHARED_PTR ShapeAspectStyle(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDoorLiningProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDoorPanelProperties : public IfcPropertySetDefinition { +public: + bool hasPanelDepth(); + IfcPositiveLengthMeasure PanelDepth(); + IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum PanelOperation(); + bool hasPanelWidth(); + IfcNormalisedRatioMeasure PanelWidth(); + IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum PanelPosition(); + bool hasShapeAspectStyle(); + SHARED_PTR ShapeAspectStyle(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDoorPanelProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDoorStyle : public IfcTypeProduct { +public: + IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum OperationType(); + IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum ConstructionType(); + bool ParameterTakesPrecedence(); + bool Sizeable(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDoorStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDraughtingCallout : public IfcGeometricRepresentationItem { +public: + SHARED_PTR< IfcTemplatedEntityList > Contents(); + SHARED_PTR< IfcTemplatedEntityList > IsRelatedFromCallout(); // INVERSE IfcDraughtingCalloutRelationship::RelatedDraughtingCallout + SHARED_PTR< IfcTemplatedEntityList > IsRelatedToCallout(); // INVERSE IfcDraughtingCalloutRelationship::RelatingDraughtingCallout + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDraughtingCallout (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDraughtingPreDefinedColour : public IfcPreDefinedColour { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDraughtingPreDefinedColour (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDraughtingPreDefinedCurveFont : public IfcPreDefinedCurveFont { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDraughtingPreDefinedCurveFont (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEdgeLoop : public IfcLoop { +public: + SHARED_PTR< IfcTemplatedEntityList > EdgeList(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEdgeLoop (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElementQuantity : public IfcPropertySetDefinition { +public: + bool hasMethodOfMeasurement(); + IfcLabel MethodOfMeasurement(); + SHARED_PTR< IfcTemplatedEntityList > Quantities(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElementQuantity (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElementType : public IfcTypeProduct { +public: + bool hasElementType(); + IfcLabel ElementType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElementType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElementarySurface : public IfcSurface { +public: + SHARED_PTR Position(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElementarySurface (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEllipseProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure SemiAxis1(); + IfcPositiveLengthMeasure SemiAxis2(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEllipseProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEnergyProperties : public IfcPropertySetDefinition { +public: + bool hasEnergySequence(); + IfcEnergySequenceEnum::IfcEnergySequenceEnum EnergySequence(); + bool hasUserDefinedEnergySequence(); + IfcLabel UserDefinedEnergySequence(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEnergyProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcExtrudedAreaSolid : public IfcSweptAreaSolid { +public: + SHARED_PTR ExtrudedDirection(); + IfcPositiveLengthMeasure Depth(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcExtrudedAreaSolid (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFaceBasedSurfaceModel : public IfcGeometricRepresentationItem { +public: + SHARED_PTR< IfcTemplatedEntityList > FbsmFaces(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFaceBasedSurfaceModel (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFillAreaStyleHatching : public IfcGeometricRepresentationItem { +public: + SHARED_PTR HatchLineAppearance(); + IfcHatchLineDistanceSelect StartOfNextHatchLine(); + bool hasPointOfReferenceHatchLine(); + SHARED_PTR PointOfReferenceHatchLine(); + bool hasPatternStart(); + SHARED_PTR PatternStart(); + IfcPlaneAngleMeasure HatchLineAngle(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFillAreaStyleHatching (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFillAreaStyleTileSymbolWithStyle : public IfcGeometricRepresentationItem { +public: + SHARED_PTR Symbol(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFillAreaStyleTileSymbolWithStyle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFillAreaStyleTiles : public IfcGeometricRepresentationItem { +public: + SHARED_PTR TilingPattern(); + SHARED_PTR< IfcTemplatedEntityList > Tiles(); + IfcPositiveRatioMeasure TilingScale(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFillAreaStyleTiles (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFluidFlowProperties : public IfcPropertySetDefinition { +public: + IfcPropertySourceEnum::IfcPropertySourceEnum PropertySource(); + bool hasFlowConditionTimeSeries(); + SHARED_PTR FlowConditionTimeSeries(); + bool hasVelocityTimeSeries(); + SHARED_PTR VelocityTimeSeries(); + bool hasFlowrateTimeSeries(); + SHARED_PTR FlowrateTimeSeries(); + SHARED_PTR Fluid(); + bool hasPressureTimeSeries(); + SHARED_PTR PressureTimeSeries(); + bool hasUserDefinedPropertySource(); + IfcLabel UserDefinedPropertySource(); + bool hasTemperatureSingleValue(); + IfcThermodynamicTemperatureMeasure TemperatureSingleValue(); + bool hasWetBulbTemperatureSingleValue(); + IfcThermodynamicTemperatureMeasure WetBulbTemperatureSingleValue(); + bool hasWetBulbTemperatureTimeSeries(); + SHARED_PTR WetBulbTemperatureTimeSeries(); + bool hasTemperatureTimeSeries(); + SHARED_PTR TemperatureTimeSeries(); + bool hasFlowrateSingleValue(); + IfcDerivedMeasureValue FlowrateSingleValue(); + bool hasFlowConditionSingleValue(); + IfcPositiveRatioMeasure FlowConditionSingleValue(); + bool hasVelocitySingleValue(); + IfcLinearVelocityMeasure VelocitySingleValue(); + bool hasPressureSingleValue(); + IfcPressureMeasure PressureSingleValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFluidFlowProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFurnishingElementType : public IfcElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFurnishingElementType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFurnitureType : public IfcFurnishingElementType { +public: + IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum AssemblyPlace(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFurnitureType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGeometricCurveSet : public IfcGeometricSet { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGeometricCurveSet (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcIShapeProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure OverallWidth(); + IfcPositiveLengthMeasure OverallDepth(); + IfcPositiveLengthMeasure WebThickness(); + IfcPositiveLengthMeasure FlangeThickness(); + bool hasFilletRadius(); + IfcPositiveLengthMeasure FilletRadius(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcIShapeProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLShapeProfileDef : public IfcParameterizedProfileDef { +public: + IfcPositiveLengthMeasure Depth(); + bool hasWidth(); + IfcPositiveLengthMeasure Width(); + IfcPositiveLengthMeasure Thickness(); + bool hasFilletRadius(); + IfcPositiveLengthMeasure FilletRadius(); + bool hasEdgeRadius(); + IfcPositiveLengthMeasure EdgeRadius(); + bool hasLegSlope(); + IfcPlaneAngleMeasure LegSlope(); + bool hasCentreOfGravityInX(); + IfcPositiveLengthMeasure CentreOfGravityInX(); + bool hasCentreOfGravityInY(); + IfcPositiveLengthMeasure CentreOfGravityInY(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLShapeProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLine : public IfcCurve { +public: + SHARED_PTR Pnt(); + SHARED_PTR Dir(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLine (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcManifoldSolidBrep : public IfcSolidModel { +public: + SHARED_PTR Outer(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcManifoldSolidBrep (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcObject : public IfcObjectDefinition { +public: + bool hasObjectType(); + IfcLabel ObjectType(); + SHARED_PTR< IfcTemplatedEntityList > IsDefinedBy(); // INVERSE IfcRelDefines::RelatedObjects + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcObject (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOffsetCurve2D : public IfcCurve { +public: + SHARED_PTR BasisCurve(); + IfcLengthMeasure Distance(); + bool SelfIntersect(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOffsetCurve2D (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOffsetCurve3D : public IfcCurve { +public: + SHARED_PTR BasisCurve(); + IfcLengthMeasure Distance(); + bool SelfIntersect(); + SHARED_PTR RefDirection(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOffsetCurve3D (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPermeableCoveringProperties : public IfcPropertySetDefinition { +public: + IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum OperationType(); + IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum PanelPosition(); + bool hasFrameDepth(); + IfcPositiveLengthMeasure FrameDepth(); + bool hasFrameThickness(); + IfcPositiveLengthMeasure FrameThickness(); + bool hasShapeAspectStyle(); + SHARED_PTR ShapeAspectStyle(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPermeableCoveringProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPlanarBox : public IfcPlanarExtent { +public: + IfcAxis2Placement Placement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPlanarBox (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPlane : public IfcElementarySurface { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPlane (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProcess : public IfcObject { +public: + SHARED_PTR< IfcTemplatedEntityList > OperatesOn(); // INVERSE IfcRelAssignsToProcess::RelatingProcess + SHARED_PTR< IfcTemplatedEntityList > IsSuccessorFrom(); // INVERSE IfcRelSequence::RelatedProcess + SHARED_PTR< IfcTemplatedEntityList > IsPredecessorTo(); // INVERSE IfcRelSequence::RelatingProcess + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProcess (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProduct : public IfcObject { +public: + bool hasObjectPlacement(); + SHARED_PTR ObjectPlacement(); + bool hasRepresentation(); + SHARED_PTR Representation(); + SHARED_PTR< IfcTemplatedEntityList > ReferencedBy(); // INVERSE IfcRelAssignsToProduct::RelatingProduct + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProduct (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProject : public IfcObject { +public: + bool hasLongName(); + IfcLabel LongName(); + bool hasPhase(); + IfcLabel Phase(); + SHARED_PTR< IfcTemplatedEntityList > RepresentationContexts(); + SHARED_PTR UnitsInContext(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProject (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProjectionCurve : public IfcAnnotationCurveOccurrence { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProjectionCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPropertySet : public IfcPropertySetDefinition { +public: + SHARED_PTR< IfcTemplatedEntityList > HasProperties(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPropertySet (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProxy : public IfcProduct { +public: + IfcObjectTypeEnum::IfcObjectTypeEnum ProxyType(); + bool hasTag(); + IfcLabel Tag(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProxy (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRectangleHollowProfileDef : public IfcRectangleProfileDef { +public: + IfcPositiveLengthMeasure WallThickness(); + bool hasInnerFilletRadius(); + IfcPositiveLengthMeasure InnerFilletRadius(); + bool hasOuterFilletRadius(); + IfcPositiveLengthMeasure OuterFilletRadius(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRectangleHollowProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRectangularPyramid : public IfcCsgPrimitive3D { +public: + IfcPositiveLengthMeasure XLength(); + IfcPositiveLengthMeasure YLength(); + IfcPositiveLengthMeasure Height(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRectangularPyramid (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRectangularTrimmedSurface : public IfcBoundedSurface { +public: + SHARED_PTR BasisSurface(); + IfcParameterValue U1(); + IfcParameterValue V1(); + IfcParameterValue U2(); + IfcParameterValue V2(); + bool Usense(); + bool Vsense(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRectangularTrimmedSurface (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssigns : public IfcRelationship { +public: + SHARED_PTR< IfcTemplatedEntityList > RelatedObjects(); + bool hasRelatedObjectsType(); + IfcObjectTypeEnum::IfcObjectTypeEnum RelatedObjectsType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssigns (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssignsToActor : public IfcRelAssigns { +public: + SHARED_PTR RelatingActor(); + bool hasActingRole(); + SHARED_PTR ActingRole(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssignsToActor (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssignsToControl : public IfcRelAssigns { +public: + SHARED_PTR RelatingControl(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssignsToControl (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssignsToGroup : public IfcRelAssigns { +public: + SHARED_PTR RelatingGroup(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssignsToGroup (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssignsToProcess : public IfcRelAssigns { +public: + SHARED_PTR RelatingProcess(); + bool hasQuantityInProcess(); + SHARED_PTR QuantityInProcess(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssignsToProcess (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssignsToProduct : public IfcRelAssigns { +public: + SHARED_PTR RelatingProduct(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssignsToProduct (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssignsToProjectOrder : public IfcRelAssignsToControl { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssignsToProjectOrder (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssignsToResource : public IfcRelAssigns { +public: + SHARED_PTR RelatingResource(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssignsToResource (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssociates : public IfcRelationship { +public: + SHARED_PTR< IfcTemplatedEntityList > RelatedObjects(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssociates (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssociatesAppliedValue : public IfcRelAssociates { +public: + SHARED_PTR RelatingAppliedValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssociatesAppliedValue (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssociatesApproval : public IfcRelAssociates { +public: + SHARED_PTR RelatingApproval(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssociatesApproval (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssociatesClassification : public IfcRelAssociates { +public: + IfcClassificationNotationSelect RelatingClassification(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssociatesClassification (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssociatesConstraint : public IfcRelAssociates { +public: + IfcLabel Intent(); + SHARED_PTR RelatingConstraint(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssociatesConstraint (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssociatesDocument : public IfcRelAssociates { +public: + IfcDocumentSelect RelatingDocument(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssociatesDocument (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssociatesLibrary : public IfcRelAssociates { +public: + IfcLibrarySelect RelatingLibrary(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssociatesLibrary (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssociatesMaterial : public IfcRelAssociates { +public: + IfcMaterialSelect RelatingMaterial(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssociatesMaterial (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssociatesProfileProperties : public IfcRelAssociates { +public: + SHARED_PTR RelatingProfileProperties(); + bool hasProfileSectionLocation(); + SHARED_PTR ProfileSectionLocation(); + bool hasProfileOrientation(); + IfcOrientationSelect ProfileOrientation(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssociatesProfileProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelConnects : public IfcRelationship { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelConnects (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelConnectsElements : public IfcRelConnects { +public: + bool hasConnectionGeometry(); + SHARED_PTR ConnectionGeometry(); + SHARED_PTR RelatingElement(); + SHARED_PTR RelatedElement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelConnectsElements (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelConnectsPathElements : public IfcRelConnectsElements { +public: + std::vector RelatingPriorities(); + std::vector RelatedPriorities(); + IfcConnectionTypeEnum::IfcConnectionTypeEnum RelatedConnectionType(); + IfcConnectionTypeEnum::IfcConnectionTypeEnum RelatingConnectionType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelConnectsPathElements (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelConnectsPortToElement : public IfcRelConnects { +public: + SHARED_PTR RelatingPort(); + SHARED_PTR RelatedElement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelConnectsPortToElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelConnectsPorts : public IfcRelConnects { +public: + SHARED_PTR RelatingPort(); + SHARED_PTR RelatedPort(); + bool hasRealizingElement(); + SHARED_PTR RealizingElement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelConnectsPorts (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelConnectsStructuralActivity : public IfcRelConnects { +public: + IfcStructuralActivityAssignmentSelect RelatingElement(); + SHARED_PTR RelatedStructuralActivity(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelConnectsStructuralActivity (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelConnectsStructuralElement : public IfcRelConnects { +public: + SHARED_PTR RelatingElement(); + SHARED_PTR RelatedStructuralMember(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelConnectsStructuralElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelConnectsStructuralMember : public IfcRelConnects { +public: + SHARED_PTR RelatingStructuralMember(); + SHARED_PTR RelatedStructuralConnection(); + bool hasAppliedCondition(); + SHARED_PTR AppliedCondition(); + bool hasAdditionalConditions(); + SHARED_PTR AdditionalConditions(); + bool hasSupportedLength(); + IfcLengthMeasure SupportedLength(); + bool hasConditionCoordinateSystem(); + SHARED_PTR ConditionCoordinateSystem(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelConnectsStructuralMember (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelConnectsWithEccentricity : public IfcRelConnectsStructuralMember { +public: + SHARED_PTR ConnectionConstraint(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelConnectsWithEccentricity (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelConnectsWithRealizingElements : public IfcRelConnectsElements { +public: + SHARED_PTR< IfcTemplatedEntityList > RealizingElements(); + bool hasConnectionType(); + IfcLabel ConnectionType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelConnectsWithRealizingElements (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelContainedInSpatialStructure : public IfcRelConnects { +public: + SHARED_PTR< IfcTemplatedEntityList > RelatedElements(); + SHARED_PTR RelatingStructure(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelContainedInSpatialStructure (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelCoversBldgElements : public IfcRelConnects { +public: + SHARED_PTR RelatingBuildingElement(); + SHARED_PTR< IfcTemplatedEntityList > RelatedCoverings(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelCoversBldgElements (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelCoversSpaces : public IfcRelConnects { +public: + SHARED_PTR RelatedSpace(); + SHARED_PTR< IfcTemplatedEntityList > RelatedCoverings(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelCoversSpaces (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelDecomposes : public IfcRelationship { +public: + SHARED_PTR RelatingObject(); + SHARED_PTR< IfcTemplatedEntityList > RelatedObjects(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelDecomposes (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelDefines : public IfcRelationship { +public: + SHARED_PTR< IfcTemplatedEntityList > RelatedObjects(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelDefines (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelDefinesByProperties : public IfcRelDefines { +public: + SHARED_PTR RelatingPropertyDefinition(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelDefinesByProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelDefinesByType : public IfcRelDefines { +public: + SHARED_PTR RelatingType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelDefinesByType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelFillsElement : public IfcRelConnects { +public: + SHARED_PTR RelatingOpeningElement(); + SHARED_PTR RelatedBuildingElement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelFillsElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelFlowControlElements : public IfcRelConnects { +public: + SHARED_PTR< IfcTemplatedEntityList > RelatedControlElements(); + SHARED_PTR RelatingFlowElement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelFlowControlElements (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelInteractionRequirements : public IfcRelConnects { +public: + bool hasDailyInteraction(); + IfcCountMeasure DailyInteraction(); + bool hasImportanceRating(); + IfcNormalisedRatioMeasure ImportanceRating(); + bool hasLocationOfInteraction(); + SHARED_PTR LocationOfInteraction(); + SHARED_PTR RelatedSpaceProgram(); + SHARED_PTR RelatingSpaceProgram(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelInteractionRequirements (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelNests : public IfcRelDecomposes { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelNests (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelOccupiesSpaces : public IfcRelAssignsToActor { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelOccupiesSpaces (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelOverridesProperties : public IfcRelDefinesByProperties { +public: + SHARED_PTR< IfcTemplatedEntityList > OverridingProperties(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelOverridesProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelProjectsElement : public IfcRelConnects { +public: + SHARED_PTR RelatingElement(); + SHARED_PTR RelatedFeatureElement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelProjectsElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelReferencedInSpatialStructure : public IfcRelConnects { +public: + SHARED_PTR< IfcTemplatedEntityList > RelatedElements(); + SHARED_PTR RelatingStructure(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelReferencedInSpatialStructure (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelSchedulesCostItems : public IfcRelAssignsToControl { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelSchedulesCostItems (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelSequence : public IfcRelConnects { +public: + SHARED_PTR RelatingProcess(); + SHARED_PTR RelatedProcess(); + IfcTimeMeasure TimeLag(); + IfcSequenceEnum::IfcSequenceEnum SequenceType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelSequence (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelServicesBuildings : public IfcRelConnects { +public: + SHARED_PTR RelatingSystem(); + SHARED_PTR< IfcTemplatedEntityList > RelatedBuildings(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelServicesBuildings (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelSpaceBoundary : public IfcRelConnects { +public: + SHARED_PTR RelatingSpace(); + bool hasRelatedBuildingElement(); + SHARED_PTR RelatedBuildingElement(); + bool hasConnectionGeometry(); + SHARED_PTR ConnectionGeometry(); + IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum PhysicalOrVirtualBoundary(); + IfcInternalOrExternalEnum::IfcInternalOrExternalEnum InternalOrExternalBoundary(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelSpaceBoundary (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelVoidsElement : public IfcRelConnects { +public: + SHARED_PTR RelatingBuildingElement(); + SHARED_PTR RelatedOpeningElement(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelVoidsElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcResource : public IfcObject { +public: + SHARED_PTR< IfcTemplatedEntityList > ResourceOf(); // INVERSE IfcRelAssignsToResource::RelatingResource + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcResource (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRevolvedAreaSolid : public IfcSweptAreaSolid { +public: + SHARED_PTR Axis(); + IfcPlaneAngleMeasure Angle(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRevolvedAreaSolid (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRightCircularCone : public IfcCsgPrimitive3D { +public: + IfcPositiveLengthMeasure Height(); + IfcPositiveLengthMeasure BottomRadius(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRightCircularCone (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRightCircularCylinder : public IfcCsgPrimitive3D { +public: + IfcPositiveLengthMeasure Height(); + IfcPositiveLengthMeasure Radius(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRightCircularCylinder (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSpatialStructureElement : public IfcProduct { +public: + bool hasLongName(); + IfcLabel LongName(); + IfcElementCompositionEnum::IfcElementCompositionEnum CompositionType(); + SHARED_PTR< IfcTemplatedEntityList > ReferencesElements(); // INVERSE IfcRelReferencedInSpatialStructure::RelatingStructure + SHARED_PTR< IfcTemplatedEntityList > ServicedBySystems(); // INVERSE IfcRelServicesBuildings::RelatedBuildings + SHARED_PTR< IfcTemplatedEntityList > ContainsElements(); // INVERSE IfcRelContainedInSpatialStructure::RelatingStructure + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSpatialStructureElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSpatialStructureElementType : public IfcElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSpatialStructureElementType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSphere : public IfcCsgPrimitive3D { +public: + IfcPositiveLengthMeasure Radius(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSphere (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralActivity : public IfcProduct { +public: + SHARED_PTR AppliedLoad(); + IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum GlobalOrLocal(); + SHARED_PTR< IfcTemplatedEntityList > AssignedToStructuralItem(); // INVERSE IfcRelConnectsStructuralActivity::RelatedStructuralActivity + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralActivity (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralItem : public IfcProduct { +public: + SHARED_PTR< IfcTemplatedEntityList > AssignedStructuralActivity(); // INVERSE IfcRelConnectsStructuralActivity::RelatingElement + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralItem (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralMember : public IfcStructuralItem { +public: + SHARED_PTR< IfcTemplatedEntityList > ReferencesElement(); // INVERSE IfcRelConnectsStructuralElement::RelatedStructuralMember + SHARED_PTR< IfcTemplatedEntityList > ConnectedBy(); // INVERSE IfcRelConnectsStructuralMember::RelatingStructuralMember + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralMember (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralReaction : public IfcStructuralActivity { +public: + SHARED_PTR< IfcTemplatedEntityList > Causes(); // INVERSE IfcStructuralAction::CausedBy + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralReaction (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralSurfaceMember : public IfcStructuralMember { +public: + IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum PredefinedType(); + bool hasThickness(); + IfcPositiveLengthMeasure Thickness(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralSurfaceMember (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralSurfaceMemberVarying : public IfcStructuralSurfaceMember { +public: + std::vector SubsequentThickness(); + SHARED_PTR VaryingThicknessLocation(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralSurfaceMemberVarying (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuredDimensionCallout : public IfcDraughtingCallout { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuredDimensionCallout (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSurfaceCurveSweptAreaSolid : public IfcSweptAreaSolid { +public: + SHARED_PTR Directrix(); + IfcParameterValue StartParam(); + IfcParameterValue EndParam(); + SHARED_PTR ReferenceSurface(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSurfaceCurveSweptAreaSolid (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSurfaceOfLinearExtrusion : public IfcSweptSurface { +public: + SHARED_PTR ExtrudedDirection(); + IfcLengthMeasure Depth(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSurfaceOfLinearExtrusion (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSurfaceOfRevolution : public IfcSweptSurface { +public: + SHARED_PTR AxisPosition(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSurfaceOfRevolution (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSystemFurnitureElementType : public IfcFurnishingElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSystemFurnitureElementType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTask : public IfcProcess { +public: + IfcIdentifier TaskId(); + bool hasStatus(); + IfcLabel Status(); + bool hasWorkMethod(); + IfcLabel WorkMethod(); + bool IsMilestone(); + bool hasPriority(); + int Priority(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTask (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTransportElementType : public IfcElementType { +public: + IfcTransportElementTypeEnum::IfcTransportElementTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTransportElementType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcActor : public IfcObject { +public: + IfcActorSelect TheActor(); + SHARED_PTR< IfcTemplatedEntityList > IsActingUpon(); // INVERSE IfcRelAssignsToActor::RelatingActor + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcActor (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAnnotation : public IfcProduct { +public: + SHARED_PTR< IfcTemplatedEntityList > ContainedInStructure(); // INVERSE IfcRelContainedInSpatialStructure::RelatedElements + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAnnotation (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAsymmetricIShapeProfileDef : public IfcIShapeProfileDef { +public: + IfcPositiveLengthMeasure TopFlangeWidth(); + bool hasTopFlangeThickness(); + IfcPositiveLengthMeasure TopFlangeThickness(); + bool hasTopFlangeFilletRadius(); + IfcPositiveLengthMeasure TopFlangeFilletRadius(); + bool hasCentreOfGravityInY(); + IfcPositiveLengthMeasure CentreOfGravityInY(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAsymmetricIShapeProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBlock : public IfcCsgPrimitive3D { +public: + IfcPositiveLengthMeasure XLength(); + IfcPositiveLengthMeasure YLength(); + IfcPositiveLengthMeasure ZLength(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBlock (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBooleanClippingResult : public IfcBooleanResult { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBooleanClippingResult (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBoundedCurve : public IfcCurve { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBoundedCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBuilding : public IfcSpatialStructureElement { +public: + bool hasElevationOfRefHeight(); + IfcLengthMeasure ElevationOfRefHeight(); + bool hasElevationOfTerrain(); + IfcLengthMeasure ElevationOfTerrain(); + bool hasBuildingAddress(); + SHARED_PTR BuildingAddress(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBuilding (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBuildingElementType : public IfcElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBuildingElementType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBuildingStorey : public IfcSpatialStructureElement { +public: + bool hasElevation(); + IfcLengthMeasure Elevation(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBuildingStorey (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCircleHollowProfileDef : public IfcCircleProfileDef { +public: + IfcPositiveLengthMeasure WallThickness(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCircleHollowProfileDef (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcColumnType : public IfcBuildingElementType { +public: + IfcColumnTypeEnum::IfcColumnTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcColumnType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCompositeCurve : public IfcBoundedCurve { +public: + SHARED_PTR< IfcTemplatedEntityList > Segments(); + bool SelfIntersect(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCompositeCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConic : public IfcCurve { +public: + IfcAxis2Placement Position(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConic (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConstructionResource : public IfcResource { +public: + bool hasResourceIdentifier(); + IfcIdentifier ResourceIdentifier(); + bool hasResourceGroup(); + IfcLabel ResourceGroup(); + bool hasResourceConsumption(); + IfcResourceConsumptionEnum::IfcResourceConsumptionEnum ResourceConsumption(); + bool hasBaseQuantity(); + SHARED_PTR BaseQuantity(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConstructionResource (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcControl : public IfcObject { +public: + SHARED_PTR< IfcTemplatedEntityList > Controls(); // INVERSE IfcRelAssignsToControl::RelatingControl + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcControl (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCostItem : public IfcControl { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCostItem (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCostSchedule : public IfcControl { +public: + bool hasSubmittedBy(); + IfcActorSelect SubmittedBy(); + bool hasPreparedBy(); + IfcActorSelect PreparedBy(); + bool hasSubmittedOn(); + IfcDateTimeSelect SubmittedOn(); + bool hasStatus(); + IfcLabel Status(); + bool hasTargetUsers(); + SHARED_PTR< IfcTemplatedEntityList > TargetUsers(); + bool hasUpdateDate(); + IfcDateTimeSelect UpdateDate(); + IfcIdentifier ID(); + IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCostSchedule (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCoveringType : public IfcBuildingElementType { +public: + IfcCoveringTypeEnum::IfcCoveringTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCoveringType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCrewResource : public IfcConstructionResource { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCrewResource (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCurtainWallType : public IfcBuildingElementType { +public: + IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCurtainWallType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDimensionCurveDirectedCallout : public IfcDraughtingCallout { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDimensionCurveDirectedCallout (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDistributionElementType : public IfcElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDistributionElementType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDistributionFlowElementType : public IfcDistributionElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDistributionFlowElementType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElectricalBaseProperties : public IfcEnergyProperties { +public: + bool hasElectricCurrentType(); + IfcElectricCurrentEnum::IfcElectricCurrentEnum ElectricCurrentType(); + IfcElectricVoltageMeasure InputVoltage(); + IfcFrequencyMeasure InputFrequency(); + bool hasFullLoadCurrent(); + IfcElectricCurrentMeasure FullLoadCurrent(); + bool hasMinimumCircuitCurrent(); + IfcElectricCurrentMeasure MinimumCircuitCurrent(); + bool hasMaximumPowerInput(); + IfcPowerMeasure MaximumPowerInput(); + bool hasRatedPowerInput(); + IfcPowerMeasure RatedPowerInput(); + int InputPhase(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElectricalBaseProperties (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElement : public IfcProduct { +public: + bool hasTag(); + IfcIdentifier Tag(); + SHARED_PTR< IfcTemplatedEntityList > HasStructuralMember(); // INVERSE IfcRelConnectsStructuralElement::RelatingElement + SHARED_PTR< IfcTemplatedEntityList > FillsVoids(); // INVERSE IfcRelFillsElement::RelatedBuildingElement + SHARED_PTR< IfcTemplatedEntityList > ConnectedTo(); // INVERSE IfcRelConnectsElements::RelatingElement + SHARED_PTR< IfcTemplatedEntityList > HasCoverings(); // INVERSE IfcRelCoversBldgElements::RelatingBuildingElement + SHARED_PTR< IfcTemplatedEntityList > HasProjections(); // INVERSE IfcRelProjectsElement::RelatingElement + SHARED_PTR< IfcTemplatedEntityList > ReferencedInStructures(); // INVERSE IfcRelReferencedInSpatialStructure::RelatedElements + SHARED_PTR< IfcTemplatedEntityList > HasPorts(); // INVERSE IfcRelConnectsPortToElement::RelatedElement + SHARED_PTR< IfcTemplatedEntityList > HasOpenings(); // INVERSE IfcRelVoidsElement::RelatingBuildingElement + SHARED_PTR< IfcTemplatedEntityList > IsConnectionRealization(); // INVERSE IfcRelConnectsWithRealizingElements::RealizingElements + SHARED_PTR< IfcTemplatedEntityList > ProvidesBoundaries(); // INVERSE IfcRelSpaceBoundary::RelatedBuildingElement + SHARED_PTR< IfcTemplatedEntityList > ConnectedFrom(); // INVERSE IfcRelConnectsElements::RelatedElement + SHARED_PTR< IfcTemplatedEntityList > ContainedInStructure(); // INVERSE IfcRelContainedInSpatialStructure::RelatedElements + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElementAssembly : public IfcElement { +public: + bool hasAssemblyPlace(); + IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum AssemblyPlace(); + IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElementAssembly (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElementComponent : public IfcElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElementComponent (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElementComponentType : public IfcElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElementComponentType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEllipse : public IfcConic { +public: + IfcPositiveLengthMeasure SemiAxis1(); + IfcPositiveLengthMeasure SemiAxis2(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEllipse (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEnergyConversionDeviceType : public IfcDistributionFlowElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEnergyConversionDeviceType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEquipmentElement : public IfcElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEquipmentElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEquipmentStandard : public IfcControl { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEquipmentStandard (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEvaporativeCoolerType : public IfcEnergyConversionDeviceType { +public: + IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEvaporativeCoolerType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEvaporatorType : public IfcEnergyConversionDeviceType { +public: + IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEvaporatorType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFacetedBrep : public IfcManifoldSolidBrep { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFacetedBrep (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFacetedBrepWithVoids : public IfcManifoldSolidBrep { +public: + SHARED_PTR< IfcTemplatedEntityList > Voids(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFacetedBrepWithVoids (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFastener : public IfcElementComponent { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFastener (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFastenerType : public IfcElementComponentType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFastenerType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFeatureElement : public IfcElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFeatureElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFeatureElementAddition : public IfcFeatureElement { +public: + SHARED_PTR< IfcTemplatedEntityList > ProjectsElements(); // INVERSE IfcRelProjectsElement::RelatedFeatureElement + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFeatureElementAddition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFeatureElementSubtraction : public IfcFeatureElement { +public: + SHARED_PTR< IfcTemplatedEntityList > VoidsElements(); // INVERSE IfcRelVoidsElement::RelatedOpeningElement + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFeatureElementSubtraction (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowControllerType : public IfcDistributionFlowElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowControllerType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowFittingType : public IfcDistributionFlowElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowFittingType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowMeterType : public IfcFlowControllerType { +public: + IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowMeterType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowMovingDeviceType : public IfcDistributionFlowElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowMovingDeviceType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowSegmentType : public IfcDistributionFlowElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowSegmentType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowStorageDeviceType : public IfcDistributionFlowElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowStorageDeviceType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowTerminalType : public IfcDistributionFlowElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowTerminalType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowTreatmentDeviceType : public IfcDistributionFlowElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowTreatmentDeviceType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFurnishingElement : public IfcElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFurnishingElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFurnitureStandard : public IfcControl { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFurnitureStandard (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGasTerminalType : public IfcFlowTerminalType { +public: + IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGasTerminalType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGrid : public IfcProduct { +public: + SHARED_PTR< IfcTemplatedEntityList > UAxes(); + SHARED_PTR< IfcTemplatedEntityList > VAxes(); + bool hasWAxes(); + SHARED_PTR< IfcTemplatedEntityList > WAxes(); + SHARED_PTR< IfcTemplatedEntityList > ContainedInStructure(); // INVERSE IfcRelContainedInSpatialStructure::RelatedElements + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGrid (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcGroup : public IfcObject { +public: + SHARED_PTR< IfcTemplatedEntityList > IsGroupedBy(); // INVERSE IfcRelAssignsToGroup::RelatingGroup + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcGroup (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcHeatExchangerType : public IfcEnergyConversionDeviceType { +public: + IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcHeatExchangerType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcHumidifierType : public IfcEnergyConversionDeviceType { +public: + IfcHumidifierTypeEnum::IfcHumidifierTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcHumidifierType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcInventory : public IfcGroup { +public: + IfcInventoryTypeEnum::IfcInventoryTypeEnum InventoryType(); + IfcActorSelect Jurisdiction(); + SHARED_PTR< IfcTemplatedEntityList > ResponsiblePersons(); + SHARED_PTR LastUpdateDate(); + bool hasCurrentValue(); + SHARED_PTR CurrentValue(); + bool hasOriginalValue(); + SHARED_PTR OriginalValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcInventory (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcJunctionBoxType : public IfcFlowFittingType { +public: + IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcJunctionBoxType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLaborResource : public IfcConstructionResource { +public: + bool hasSkillSet(); + IfcText SkillSet(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLaborResource (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLampType : public IfcFlowTerminalType { +public: + IfcLampTypeEnum::IfcLampTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLampType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLightFixtureType : public IfcFlowTerminalType { +public: + IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLightFixtureType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcLinearDimension : public IfcDimensionCurveDirectedCallout { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcLinearDimension (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMechanicalFastener : public IfcFastener { +public: + bool hasNominalDiameter(); + IfcPositiveLengthMeasure NominalDiameter(); + bool hasNominalLength(); + IfcPositiveLengthMeasure NominalLength(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMechanicalFastener (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMechanicalFastenerType : public IfcFastenerType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMechanicalFastenerType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMemberType : public IfcBuildingElementType { +public: + IfcMemberTypeEnum::IfcMemberTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMemberType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMotorConnectionType : public IfcEnergyConversionDeviceType { +public: + IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMotorConnectionType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMove : public IfcTask { +public: + SHARED_PTR MoveFrom(); + SHARED_PTR MoveTo(); + bool hasPunchList(); + std::vector PunchList(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMove (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOccupant : public IfcActor { +public: + IfcOccupantTypeEnum::IfcOccupantTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOccupant (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOpeningElement : public IfcFeatureElementSubtraction { +public: + SHARED_PTR< IfcTemplatedEntityList > HasFillings(); // INVERSE IfcRelFillsElement::RelatingOpeningElement + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOpeningElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOrderAction : public IfcTask { +public: + IfcIdentifier ActionID(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOrderAction (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcOutletType : public IfcFlowTerminalType { +public: + IfcOutletTypeEnum::IfcOutletTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcOutletType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPerformanceHistory : public IfcControl { +public: + IfcLabel LifeCyclePhase(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPerformanceHistory (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPermit : public IfcControl { +public: + IfcIdentifier PermitID(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPermit (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPipeFittingType : public IfcFlowFittingType { +public: + IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPipeFittingType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPipeSegmentType : public IfcFlowSegmentType { +public: + IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPipeSegmentType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPlateType : public IfcBuildingElementType { +public: + IfcPlateTypeEnum::IfcPlateTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPlateType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPolyline : public IfcBoundedCurve { +public: + SHARED_PTR< IfcTemplatedEntityList > Points(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPolyline (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPort : public IfcProduct { +public: + SHARED_PTR< IfcTemplatedEntityList > ContainedIn(); // INVERSE IfcRelConnectsPortToElement::RelatingPort + SHARED_PTR< IfcTemplatedEntityList > ConnectedFrom(); // INVERSE IfcRelConnectsPorts::RelatedPort + SHARED_PTR< IfcTemplatedEntityList > ConnectedTo(); // INVERSE IfcRelConnectsPorts::RelatingPort + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPort (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProcedure : public IfcProcess { +public: + IfcIdentifier ProcedureID(); + IfcProcedureTypeEnum::IfcProcedureTypeEnum ProcedureType(); + bool hasUserDefinedProcedureType(); + IfcLabel UserDefinedProcedureType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProcedure (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProjectOrder : public IfcControl { +public: + IfcIdentifier ID(); + IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum PredefinedType(); + bool hasStatus(); + IfcLabel Status(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProjectOrder (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProjectOrderRecord : public IfcControl { +public: + SHARED_PTR< IfcTemplatedEntityList > Records(); + IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProjectOrderRecord (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProjectionElement : public IfcFeatureElementAddition { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProjectionElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcProtectiveDeviceType : public IfcFlowControllerType { +public: + IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcProtectiveDeviceType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPumpType : public IfcFlowMovingDeviceType { +public: + IfcPumpTypeEnum::IfcPumpTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPumpType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRadiusDimension : public IfcDimensionCurveDirectedCallout { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRadiusDimension (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRailingType : public IfcBuildingElementType { +public: + IfcRailingTypeEnum::IfcRailingTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRailingType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRampFlightType : public IfcBuildingElementType { +public: + IfcRampFlightTypeEnum::IfcRampFlightTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRampFlightType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAggregates : public IfcRelDecomposes { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAggregates (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRelAssignsTasks : public IfcRelAssignsToControl { +public: + bool hasTimeForTask(); + SHARED_PTR TimeForTask(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRelAssignsTasks (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSanitaryTerminalType : public IfcFlowTerminalType { +public: + IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSanitaryTerminalType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcScheduleTimeControl : public IfcControl { +public: + bool hasActualStart(); + IfcDateTimeSelect ActualStart(); + bool hasEarlyStart(); + IfcDateTimeSelect EarlyStart(); + bool hasLateStart(); + IfcDateTimeSelect LateStart(); + bool hasScheduleStart(); + IfcDateTimeSelect ScheduleStart(); + bool hasActualFinish(); + IfcDateTimeSelect ActualFinish(); + bool hasEarlyFinish(); + IfcDateTimeSelect EarlyFinish(); + bool hasLateFinish(); + IfcDateTimeSelect LateFinish(); + bool hasScheduleFinish(); + IfcDateTimeSelect ScheduleFinish(); + bool hasScheduleDuration(); + IfcTimeMeasure ScheduleDuration(); + bool hasActualDuration(); + IfcTimeMeasure ActualDuration(); + bool hasRemainingTime(); + IfcTimeMeasure RemainingTime(); + bool hasFreeFloat(); + IfcTimeMeasure FreeFloat(); + bool hasTotalFloat(); + IfcTimeMeasure TotalFloat(); + bool hasIsCritical(); + bool IsCritical(); + bool hasStatusTime(); + IfcDateTimeSelect StatusTime(); + bool hasStartFloat(); + IfcTimeMeasure StartFloat(); + bool hasFinishFloat(); + IfcTimeMeasure FinishFloat(); + bool hasCompletion(); + IfcPositiveRatioMeasure Completion(); + SHARED_PTR< IfcTemplatedEntityList > ScheduleTimeControlAssigned(); // INVERSE IfcRelAssignsTasks::TimeForTask + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcScheduleTimeControl (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcServiceLife : public IfcControl { +public: + IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum ServiceLifeType(); + IfcTimeMeasure ServiceLifeDuration(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcServiceLife (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSite : public IfcSpatialStructureElement { +public: + bool hasRefLatitude(); + IfcCompoundPlaneAngleMeasure RefLatitude(); + bool hasRefLongitude(); + IfcCompoundPlaneAngleMeasure RefLongitude(); + bool hasRefElevation(); + IfcLengthMeasure RefElevation(); + bool hasLandTitleNumber(); + IfcLabel LandTitleNumber(); + bool hasSiteAddress(); + SHARED_PTR SiteAddress(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSite (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSlabType : public IfcBuildingElementType { +public: + IfcSlabTypeEnum::IfcSlabTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSlabType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSpace : public IfcSpatialStructureElement { +public: + IfcInternalOrExternalEnum::IfcInternalOrExternalEnum InteriorOrExteriorSpace(); + bool hasElevationWithFlooring(); + IfcLengthMeasure ElevationWithFlooring(); + SHARED_PTR< IfcTemplatedEntityList > HasCoverings(); // INVERSE IfcRelCoversSpaces::RelatedSpace + SHARED_PTR< IfcTemplatedEntityList > BoundedBy(); // INVERSE IfcRelSpaceBoundary::RelatingSpace + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSpace (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSpaceHeaterType : public IfcEnergyConversionDeviceType { +public: + IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSpaceHeaterType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSpaceProgram : public IfcControl { +public: + IfcIdentifier SpaceProgramIdentifier(); + bool hasMaxRequiredArea(); + IfcAreaMeasure MaxRequiredArea(); + bool hasMinRequiredArea(); + IfcAreaMeasure MinRequiredArea(); + bool hasRequestedLocation(); + SHARED_PTR RequestedLocation(); + IfcAreaMeasure StandardRequiredArea(); + SHARED_PTR< IfcTemplatedEntityList > HasInteractionReqsFrom(); // INVERSE IfcRelInteractionRequirements::RelatedSpaceProgram + SHARED_PTR< IfcTemplatedEntityList > HasInteractionReqsTo(); // INVERSE IfcRelInteractionRequirements::RelatingSpaceProgram + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSpaceProgram (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSpaceType : public IfcSpatialStructureElementType { +public: + IfcSpaceTypeEnum::IfcSpaceTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSpaceType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStackTerminalType : public IfcFlowTerminalType { +public: + IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStackTerminalType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStairFlightType : public IfcBuildingElementType { +public: + IfcStairFlightTypeEnum::IfcStairFlightTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStairFlightType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralAction : public IfcStructuralActivity { +public: + bool DestabilizingLoad(); + bool hasCausedBy(); + SHARED_PTR CausedBy(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralAction (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralConnection : public IfcStructuralItem { +public: + bool hasAppliedCondition(); + SHARED_PTR AppliedCondition(); + SHARED_PTR< IfcTemplatedEntityList > ConnectsStructuralMembers(); // INVERSE IfcRelConnectsStructuralMember::RelatedStructuralConnection + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralConnection (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralCurveConnection : public IfcStructuralConnection { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralCurveConnection (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralCurveMember : public IfcStructuralMember { +public: + IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralCurveMember (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralCurveMemberVarying : public IfcStructuralCurveMember { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralCurveMemberVarying (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLinearAction : public IfcStructuralAction { +public: + IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum ProjectedOrTrue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLinearAction (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLinearActionVarying : public IfcStructuralLinearAction { +public: + SHARED_PTR VaryingAppliedLoadLocation(); + SHARED_PTR< IfcTemplatedEntityList > SubsequentAppliedLoads(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLinearActionVarying (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralLoadGroup : public IfcGroup { +public: + IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum PredefinedType(); + IfcActionTypeEnum::IfcActionTypeEnum ActionType(); + IfcActionSourceTypeEnum::IfcActionSourceTypeEnum ActionSource(); + bool hasCoefficient(); + IfcRatioMeasure Coefficient(); + bool hasPurpose(); + IfcLabel Purpose(); + SHARED_PTR< IfcTemplatedEntityList > SourceOfResultGroup(); // INVERSE IfcStructuralResultGroup::ResultForLoadGroup + SHARED_PTR< IfcTemplatedEntityList > LoadGroupFor(); // INVERSE IfcStructuralAnalysisModel::LoadedBy + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralLoadGroup (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralPlanarAction : public IfcStructuralAction { +public: + IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum ProjectedOrTrue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralPlanarAction (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralPlanarActionVarying : public IfcStructuralPlanarAction { +public: + SHARED_PTR VaryingAppliedLoadLocation(); + SHARED_PTR< IfcTemplatedEntityList > SubsequentAppliedLoads(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralPlanarActionVarying (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralPointAction : public IfcStructuralAction { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralPointAction (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralPointConnection : public IfcStructuralConnection { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralPointConnection (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralPointReaction : public IfcStructuralReaction { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralPointReaction (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralResultGroup : public IfcGroup { +public: + IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum TheoryType(); + bool hasResultForLoadGroup(); + SHARED_PTR ResultForLoadGroup(); + bool IsLinear(); + SHARED_PTR< IfcTemplatedEntityList > ResultGroupFor(); // INVERSE IfcStructuralAnalysisModel::HasResults + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralResultGroup (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralSurfaceConnection : public IfcStructuralConnection { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralSurfaceConnection (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSubContractResource : public IfcConstructionResource { +public: + bool hasSubContractor(); + IfcActorSelect SubContractor(); + bool hasJobDescription(); + IfcText JobDescription(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSubContractResource (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSwitchingDeviceType : public IfcFlowControllerType { +public: + IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSwitchingDeviceType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSystem : public IfcGroup { +public: + SHARED_PTR< IfcTemplatedEntityList > ServicesBuildings(); // INVERSE IfcRelServicesBuildings::RelatingSystem + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSystem (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTankType : public IfcFlowStorageDeviceType { +public: + IfcTankTypeEnum::IfcTankTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTankType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTimeSeriesSchedule : public IfcControl { +public: + bool hasApplicableDates(); + SHARED_PTR< IfcTemplatedEntityList > ApplicableDates(); + IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum TimeSeriesScheduleType(); + SHARED_PTR TimeSeries(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTimeSeriesSchedule (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTransformerType : public IfcEnergyConversionDeviceType { +public: + IfcTransformerTypeEnum::IfcTransformerTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTransformerType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTransportElement : public IfcElement { +public: + bool hasOperationType(); + IfcTransportElementTypeEnum::IfcTransportElementTypeEnum OperationType(); + bool hasCapacityByWeight(); + IfcMassMeasure CapacityByWeight(); + bool hasCapacityByNumber(); + IfcCountMeasure CapacityByNumber(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTransportElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTrimmedCurve : public IfcBoundedCurve { +public: + SHARED_PTR BasisCurve(); + SHARED_PTR< IfcTemplatedEntityList > Trim1(); + SHARED_PTR< IfcTemplatedEntityList > Trim2(); + bool SenseAgreement(); + IfcTrimmingPreference::IfcTrimmingPreference MasterRepresentation(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTrimmedCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTubeBundleType : public IfcEnergyConversionDeviceType { +public: + IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTubeBundleType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcUnitaryEquipmentType : public IfcEnergyConversionDeviceType { +public: + IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcUnitaryEquipmentType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcValveType : public IfcFlowControllerType { +public: + IfcValveTypeEnum::IfcValveTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcValveType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcVirtualElement : public IfcElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcVirtualElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWallType : public IfcBuildingElementType { +public: + IfcWallTypeEnum::IfcWallTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWallType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWasteTerminalType : public IfcFlowTerminalType { +public: + IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWasteTerminalType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWorkControl : public IfcControl { +public: + IfcIdentifier Identifier(); + IfcDateTimeSelect CreationDate(); + bool hasCreators(); + SHARED_PTR< IfcTemplatedEntityList > Creators(); + bool hasPurpose(); + IfcLabel Purpose(); + bool hasDuration(); + IfcTimeMeasure Duration(); + bool hasTotalFloat(); + IfcTimeMeasure TotalFloat(); + IfcDateTimeSelect StartTime(); + bool hasFinishTime(); + IfcDateTimeSelect FinishTime(); + bool hasWorkControlType(); + IfcWorkControlTypeEnum::IfcWorkControlTypeEnum WorkControlType(); + bool hasUserDefinedControlType(); + IfcLabel UserDefinedControlType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWorkControl (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWorkPlan : public IfcWorkControl { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWorkPlan (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWorkSchedule : public IfcWorkControl { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWorkSchedule (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcZone : public IfcGroup { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcZone (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class Ifc2DCompositeCurve : public IfcCompositeCurve { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + Ifc2DCompositeCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcActionRequest : public IfcControl { +public: + IfcIdentifier RequestID(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcActionRequest (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAirTerminalBoxType : public IfcFlowControllerType { +public: + IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAirTerminalBoxType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAirTerminalType : public IfcFlowTerminalType { +public: + IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAirTerminalType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAirToAirHeatRecoveryType : public IfcEnergyConversionDeviceType { +public: + IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAirToAirHeatRecoveryType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAngularDimension : public IfcDimensionCurveDirectedCallout { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAngularDimension (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAsset : public IfcGroup { +public: + IfcIdentifier AssetID(); + SHARED_PTR OriginalValue(); + SHARED_PTR CurrentValue(); + SHARED_PTR TotalReplacementCost(); + IfcActorSelect Owner(); + IfcActorSelect User(); + SHARED_PTR ResponsiblePerson(); + SHARED_PTR IncorporationDate(); + SHARED_PTR DepreciatedValue(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAsset (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBSplineCurve : public IfcBoundedCurve { +public: + int Degree(); + SHARED_PTR< IfcTemplatedEntityList > ControlPointsList(); + IfcBSplineCurveForm::IfcBSplineCurveForm CurveForm(); + bool ClosedCurve(); + bool SelfIntersect(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBSplineCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBeamType : public IfcBuildingElementType { +public: + IfcBeamTypeEnum::IfcBeamTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBeamType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBezierCurve : public IfcBSplineCurve { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBezierCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBoilerType : public IfcEnergyConversionDeviceType { +public: + IfcBoilerTypeEnum::IfcBoilerTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBoilerType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBuildingElement : public IfcElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBuildingElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBuildingElementComponent : public IfcBuildingElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBuildingElementComponent (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBuildingElementPart : public IfcBuildingElementComponent { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBuildingElementPart (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBuildingElementProxy : public IfcBuildingElement { +public: + bool hasCompositionType(); + IfcElementCompositionEnum::IfcElementCompositionEnum CompositionType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBuildingElementProxy (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBuildingElementProxyType : public IfcBuildingElementType { +public: + IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBuildingElementProxyType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCableCarrierFittingType : public IfcFlowFittingType { +public: + IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCableCarrierFittingType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCableCarrierSegmentType : public IfcFlowSegmentType { +public: + IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCableCarrierSegmentType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCableSegmentType : public IfcFlowSegmentType { +public: + IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCableSegmentType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcChillerType : public IfcEnergyConversionDeviceType { +public: + IfcChillerTypeEnum::IfcChillerTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcChillerType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCircle : public IfcConic { +public: + IfcPositiveLengthMeasure Radius(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCircle (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCoilType : public IfcEnergyConversionDeviceType { +public: + IfcCoilTypeEnum::IfcCoilTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCoilType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcColumn : public IfcBuildingElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcColumn (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCompressorType : public IfcFlowMovingDeviceType { +public: + IfcCompressorTypeEnum::IfcCompressorTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCompressorType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCondenserType : public IfcEnergyConversionDeviceType { +public: + IfcCondenserTypeEnum::IfcCondenserTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCondenserType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCondition : public IfcGroup { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCondition (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConditionCriterion : public IfcControl { +public: + IfcConditionCriterionSelect Criterion(); + IfcDateTimeSelect CriterionDateTime(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConditionCriterion (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConstructionEquipmentResource : public IfcConstructionResource { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConstructionEquipmentResource (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConstructionMaterialResource : public IfcConstructionResource { +public: + bool hasSuppliers(); + SHARED_PTR< IfcTemplatedEntityList > Suppliers(); + bool hasUsageRatio(); + IfcRatioMeasure UsageRatio(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConstructionMaterialResource (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcConstructionProductResource : public IfcConstructionResource { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcConstructionProductResource (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCooledBeamType : public IfcEnergyConversionDeviceType { +public: + IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCooledBeamType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCoolingTowerType : public IfcEnergyConversionDeviceType { +public: + IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCoolingTowerType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCovering : public IfcBuildingElement { +public: + bool hasPredefinedType(); + IfcCoveringTypeEnum::IfcCoveringTypeEnum PredefinedType(); + SHARED_PTR< IfcTemplatedEntityList > CoversSpaces(); // INVERSE IfcRelCoversSpaces::RelatedCoverings + SHARED_PTR< IfcTemplatedEntityList > Covers(); // INVERSE IfcRelCoversBldgElements::RelatedCoverings + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCovering (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcCurtainWall : public IfcBuildingElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcCurtainWall (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDamperType : public IfcFlowControllerType { +public: + IfcDamperTypeEnum::IfcDamperTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDamperType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDiameterDimension : public IfcDimensionCurveDirectedCallout { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDiameterDimension (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDiscreteAccessory : public IfcElementComponent { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDiscreteAccessory (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDiscreteAccessoryType : public IfcElementComponentType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDiscreteAccessoryType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDistributionChamberElementType : public IfcDistributionFlowElementType { +public: + IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDistributionChamberElementType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDistributionControlElementType : public IfcDistributionElementType { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDistributionControlElementType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDistributionElement : public IfcElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDistributionElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDistributionFlowElement : public IfcDistributionElement { +public: + SHARED_PTR< IfcTemplatedEntityList > HasControlElements(); // INVERSE IfcRelFlowControlElements::RelatingFlowElement + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDistributionFlowElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDistributionPort : public IfcPort { +public: + bool hasFlowDirection(); + IfcFlowDirectionEnum::IfcFlowDirectionEnum FlowDirection(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDistributionPort (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDoor : public IfcBuildingElement { +public: + bool hasOverallHeight(); + IfcPositiveLengthMeasure OverallHeight(); + bool hasOverallWidth(); + IfcPositiveLengthMeasure OverallWidth(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDoor (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDuctFittingType : public IfcFlowFittingType { +public: + IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDuctFittingType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDuctSegmentType : public IfcFlowSegmentType { +public: + IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDuctSegmentType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDuctSilencerType : public IfcFlowTreatmentDeviceType { +public: + IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDuctSilencerType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEdgeFeature : public IfcFeatureElementSubtraction { +public: + bool hasFeatureLength(); + IfcPositiveLengthMeasure FeatureLength(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEdgeFeature (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElectricApplianceType : public IfcFlowTerminalType { +public: + IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElectricApplianceType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElectricFlowStorageDeviceType : public IfcFlowStorageDeviceType { +public: + IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElectricFlowStorageDeviceType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElectricGeneratorType : public IfcEnergyConversionDeviceType { +public: + IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElectricGeneratorType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElectricHeaterType : public IfcFlowTerminalType { +public: + IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElectricHeaterType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElectricMotorType : public IfcEnergyConversionDeviceType { +public: + IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElectricMotorType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElectricTimeControlType : public IfcFlowControllerType { +public: + IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElectricTimeControlType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElectricalCircuit : public IfcSystem { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElectricalCircuit (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElectricalElement : public IfcElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElectricalElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcEnergyConversionDevice : public IfcDistributionFlowElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcEnergyConversionDevice (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFanType : public IfcFlowMovingDeviceType { +public: + IfcFanTypeEnum::IfcFanTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFanType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFilterType : public IfcFlowTreatmentDeviceType { +public: + IfcFilterTypeEnum::IfcFilterTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFilterType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFireSuppressionTerminalType : public IfcFlowTerminalType { +public: + IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFireSuppressionTerminalType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowController : public IfcDistributionFlowElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowController (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowFitting : public IfcDistributionFlowElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowFitting (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowInstrumentType : public IfcDistributionControlElementType { +public: + IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowInstrumentType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowMovingDevice : public IfcDistributionFlowElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowMovingDevice (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowSegment : public IfcDistributionFlowElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowSegment (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowStorageDevice : public IfcDistributionFlowElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowStorageDevice (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowTerminal : public IfcDistributionFlowElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowTerminal (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFlowTreatmentDevice : public IfcDistributionFlowElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFlowTreatmentDevice (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcFooting : public IfcBuildingElement { +public: + IfcFootingTypeEnum::IfcFootingTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcFooting (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcMember : public IfcBuildingElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcMember (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPile : public IfcBuildingElement { +public: + IfcPileTypeEnum::IfcPileTypeEnum PredefinedType(); + bool hasConstructionType(); + IfcPileConstructionEnum::IfcPileConstructionEnum ConstructionType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPile (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcPlate : public IfcBuildingElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcPlate (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRailing : public IfcBuildingElement { +public: + bool hasPredefinedType(); + IfcRailingTypeEnum::IfcRailingTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRailing (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRamp : public IfcBuildingElement { +public: + IfcRampTypeEnum::IfcRampTypeEnum ShapeType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRamp (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRampFlight : public IfcBuildingElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRampFlight (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRationalBezierCurve : public IfcBezierCurve { +public: + std::vector WeightsData(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRationalBezierCurve (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcReinforcingElement : public IfcBuildingElementComponent { +public: + bool hasSteelGrade(); + IfcLabel SteelGrade(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcReinforcingElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcReinforcingMesh : public IfcReinforcingElement { +public: + bool hasMeshLength(); + IfcPositiveLengthMeasure MeshLength(); + bool hasMeshWidth(); + IfcPositiveLengthMeasure MeshWidth(); + IfcPositiveLengthMeasure LongitudinalBarNominalDiameter(); + IfcPositiveLengthMeasure TransverseBarNominalDiameter(); + IfcAreaMeasure LongitudinalBarCrossSectionArea(); + IfcAreaMeasure TransverseBarCrossSectionArea(); + IfcPositiveLengthMeasure LongitudinalBarSpacing(); + IfcPositiveLengthMeasure TransverseBarSpacing(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcReinforcingMesh (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRoof : public IfcBuildingElement { +public: + IfcRoofTypeEnum::IfcRoofTypeEnum ShapeType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRoof (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcRoundedEdgeFeature : public IfcEdgeFeature { +public: + bool hasRadius(); + IfcPositiveLengthMeasure Radius(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcRoundedEdgeFeature (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSensorType : public IfcDistributionControlElementType { +public: + IfcSensorTypeEnum::IfcSensorTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSensorType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcSlab : public IfcBuildingElement { +public: + bool hasPredefinedType(); + IfcSlabTypeEnum::IfcSlabTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcSlab (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStair : public IfcBuildingElement { +public: + IfcStairTypeEnum::IfcStairTypeEnum ShapeType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStair (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStairFlight : public IfcBuildingElement { +public: + bool hasNumberOfRiser(); + int NumberOfRiser(); + bool hasNumberOfTreads(); + int NumberOfTreads(); + bool hasRiserHeight(); + IfcPositiveLengthMeasure RiserHeight(); + bool hasTreadLength(); + IfcPositiveLengthMeasure TreadLength(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStairFlight (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcStructuralAnalysisModel : public IfcSystem { +public: + IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum PredefinedType(); + bool hasOrientationOf2DPlane(); + SHARED_PTR OrientationOf2DPlane(); + bool hasLoadedBy(); + SHARED_PTR< IfcTemplatedEntityList > LoadedBy(); + bool hasHasResults(); + SHARED_PTR< IfcTemplatedEntityList > HasResults(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcStructuralAnalysisModel (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTendon : public IfcReinforcingElement { +public: + IfcTendonTypeEnum::IfcTendonTypeEnum PredefinedType(); + IfcPositiveLengthMeasure NominalDiameter(); + IfcAreaMeasure CrossSectionArea(); + bool hasTensionForce(); + IfcForceMeasure TensionForce(); + bool hasPreStress(); + IfcPressureMeasure PreStress(); + bool hasFrictionCoefficient(); + IfcNormalisedRatioMeasure FrictionCoefficient(); + bool hasAnchorageSlip(); + IfcPositiveLengthMeasure AnchorageSlip(); + bool hasMinCurvatureRadius(); + IfcPositiveLengthMeasure MinCurvatureRadius(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTendon (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcTendonAnchor : public IfcReinforcingElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcTendonAnchor (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcVibrationIsolatorType : public IfcDiscreteAccessoryType { +public: + IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcVibrationIsolatorType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWall : public IfcBuildingElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWall (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWallStandardCase : public IfcWall { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWallStandardCase (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcWindow : public IfcBuildingElement { +public: + bool hasOverallHeight(); + IfcPositiveLengthMeasure OverallHeight(); + bool hasOverallWidth(); + IfcPositiveLengthMeasure OverallWidth(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcWindow (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcActuatorType : public IfcDistributionControlElementType { +public: + IfcActuatorTypeEnum::IfcActuatorTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcActuatorType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcAlarmType : public IfcDistributionControlElementType { +public: + IfcAlarmTypeEnum::IfcAlarmTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcAlarmType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcBeam : public IfcBuildingElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcBeam (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcChamferEdgeFeature : public IfcEdgeFeature { +public: + bool hasWidth(); + IfcPositiveLengthMeasure Width(); + bool hasHeight(); + IfcPositiveLengthMeasure Height(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcChamferEdgeFeature (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcControllerType : public IfcDistributionControlElementType { +public: + IfcControllerTypeEnum::IfcControllerTypeEnum PredefinedType(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcControllerType (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDistributionChamberElement : public IfcDistributionFlowElement { +public: + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDistributionChamberElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcDistributionControlElement : public IfcDistributionElement { +public: + bool hasControlElementId(); + IfcIdentifier ControlElementId(); + SHARED_PTR< IfcTemplatedEntityList > AssignedToFlowElement(); // INVERSE IfcRelFlowControlElements::RelatedControlElements + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcDistributionControlElement (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcElectricDistributionPoint : public IfcFlowController { +public: + IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum DistributionPointFunction(); + bool hasUserDefinedFunction(); + IfcLabel UserDefinedFunction(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcElectricDistributionPoint (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; +class IfcReinforcingBar : public IfcReinforcingElement { +public: + IfcPositiveLengthMeasure NominalDiameter(); + IfcAreaMeasure CrossSectionArea(); + bool hasBarLength(); + IfcPositiveLengthMeasure BarLength(); + IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum BarRole(); + bool hasBarSurface(); + IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum BarSurface(); + bool is(Type::Enum v); + Type::Enum type(); + static Type::Enum Class(); + IfcReinforcingBar (IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + typedef SHARED_PTR ptr; + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; +}; + +IfcSchemaEntity SchemaEntity(IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); + +} + +#endif \ No newline at end of file diff --git a/src/ifcparse/Ifc2x3enum.h b/src/ifcparse/Ifc2x3enum.h new file mode 100644 index 0000000000..09433a8691 --- /dev/null +++ b/src/ifcparse/Ifc2x3enum.h @@ -0,0 +1,42 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +/******************************************************************************** + * * + * This file has been generated from IFC2X3_TC1.exp. Do not make modifications * + * but instead modify the python script that has been used to generate this. * + * * + ********************************************************************************/ + +#ifndef IFC2X3ENUM_H +#define IFC2X3ENUM_H + +namespace Ifc2x3 { + +namespace Type { + typedef enum { + IfcSoundPowerMeasure, IfcRotationalFrequencyMeasure, IfcSpecificHeatCapacityMeasure, IfcElectricConductanceMeasure, IfcElectricChargeMeasure, IfcPositiveLengthMeasure, IfcAngularVelocityMeasure, IfcNullStyle, IfcIonConcentrationMeasure, IfcModulusOfLinearSubgradeReactionMeasure, IfcHeatFluxDensityMeasure, IfcHeatingValueMeasure, IfcForceMeasure, IfcPositiveRatioMeasure, IfcMolecularWeightMeasure, IfcLuminousFluxMeasure, IfcNormalisedRatioMeasure, IfcLabel, IfcTimeStamp, IfcNumericMeasure, IfcRotationalMassMeasure, IfcLinearForceMeasure, IfcKinematicViscosityMeasure, IfcMassDensityMeasure, IfcIntegerCountRateMeasure, IfcRadioActivityMeasure, IfcReal, IfcLinearMomentMeasure, IfcElectricCurrentMeasure, IfcThermalTransmittanceMeasure, IfcModulusOfElasticityMeasure, IfcInductanceMeasure, IfcWarpingMomentMeasure, IfcDynamicViscosityMeasure, IfcAreaMeasure, IfcLogical, IfcAmountOfSubstanceMeasure, IfcContextDependentMeasure, IfcThermalConductivityMeasure, IfcEnergyMeasure, IfcRotationalStiffnessMeasure, IfcDerivedMeasureValue, IfcPowerMeasure, IfcThermalExpansionCoefficientMeasure, IfcTorqueMeasure, IfcMassPerLengthMeasure, IfcCountMeasure, IfcCurveStyleFontSelect, IfcVolumetricFlowRateMeasure, IfcModulusOfSubgradeReactionMeasure, IfcMassFlowRateMeasure, IfcMonetaryMeasure, IfcTemperatureGradientMeasure, IfcColour, IfcVolumeMeasure, IfcSectionalAreaIntegralMeasure, IfcVaporPermeabilityMeasure, IfcLinearVelocityMeasure, IfcLengthMeasure, IfcModulusOfRotationalSubgradeReactionMeasure, IfcPlanarForceMeasure, IfcInteger, IfcSimpleValue, IfcMeasureValue, IfcPlaneAngleMeasure, IfcWarpingConstantMeasure, IfcElectricCapacitanceMeasure, IfcSoundPressureMeasure, IfcSpecularRoughness, IfcIlluminanceMeasure, IfcText, IfcTimeMeasure, IfcAccelerationMeasure, IfcLuminousIntensityMeasure, IfcPressureMeasure, IfcElectricVoltageMeasure, IfcThermodynamicTemperatureMeasure, IfcMagneticFluxMeasure, IfcSolidAngleMeasure, IfcFrequencyMeasure, IfcPHMeasure, IfcThermalAdmittanceMeasure, IfcSpecularExponent, IfcDateTimeSelect, IfcLinearStiffnessMeasure, IfcCompoundPlaneAngleMeasure, IfcCurvatureMeasure, IfcAbsorbedDoseMeasure, IfcParameterValue, IfcDescriptiveMeasure, IfcMomentOfInertiaMeasure, IfcDoseEquivalentMeasure, IfcComplexNumber, IfcRatioMeasure, IfcLuminousIntensityDistributionMeasure, IfcIsothermalMoistureCapacityMeasure, IfcElectricResistanceMeasure, IfcThermalResistanceMeasure, IfcShearModulusMeasure, IfcIdentifier, IfcBoolean, IfcSectionModulusMeasure, IfcMassMeasure, IfcMoistureDiffusivityMeasure, IfcPositivePlaneAngleMeasure, IfcMagneticFluxDensityMeasure, Ifc2DCompositeCurve, IfcActionRequest, IfcActor, IfcActorRole, IfcActuatorType, IfcAddress, IfcAirTerminalBoxType, IfcAirTerminalType, IfcAirToAirHeatRecoveryType, IfcAlarmType, IfcAngularDimension, IfcAnnotation, IfcAnnotationCurveOccurrence, IfcAnnotationFillArea, IfcAnnotationFillAreaOccurrence, IfcAnnotationOccurrence, IfcAnnotationSurface, IfcAnnotationSurfaceOccurrence, IfcAnnotationSymbolOccurrence, IfcAnnotationTextOccurrence, IfcApplication, IfcAppliedValue, IfcAppliedValueRelationship, IfcApproval, IfcApprovalActorRelationship, IfcApprovalPropertyRelationship, IfcApprovalRelationship, IfcArbitraryClosedProfileDef, IfcArbitraryOpenProfileDef, IfcArbitraryProfileDefWithVoids, IfcAsset, IfcAsymmetricIShapeProfileDef, IfcAxis1Placement, IfcAxis2Placement2D, IfcAxis2Placement3D, IfcBSplineCurve, IfcBeam, IfcBeamType, IfcBezierCurve, IfcBlobTexture, IfcBlock, IfcBoilerType, IfcBooleanClippingResult, IfcBooleanResult, IfcBoundaryCondition, IfcBoundaryEdgeCondition, IfcBoundaryFaceCondition, IfcBoundaryNodeCondition, IfcBoundaryNodeConditionWarping, IfcBoundedCurve, IfcBoundedSurface, IfcBoundingBox, IfcBoxedHalfSpace, IfcBuilding, IfcBuildingElement, IfcBuildingElementComponent, IfcBuildingElementPart, IfcBuildingElementProxy, IfcBuildingElementProxyType, IfcBuildingElementType, IfcBuildingStorey, IfcCShapeProfileDef, IfcCableCarrierFittingType, IfcCableCarrierSegmentType, IfcCableSegmentType, IfcCalendarDate, IfcCartesianPoint, IfcCartesianTransformationOperator, IfcCartesianTransformationOperator2D, IfcCartesianTransformationOperator2DnonUniform, IfcCartesianTransformationOperator3D, IfcCartesianTransformationOperator3DnonUniform, IfcCenterLineProfileDef, IfcChamferEdgeFeature, IfcChillerType, IfcCircle, IfcCircleHollowProfileDef, IfcCircleProfileDef, IfcClassification, IfcClassificationItem, IfcClassificationItemRelationship, IfcClassificationNotation, IfcClassificationNotationFacet, IfcClassificationReference, IfcClosedShell, IfcCoilType, IfcColourRgb, IfcColourSpecification, IfcColumn, IfcColumnType, IfcComplexProperty, IfcCompositeCurve, IfcCompositeCurveSegment, IfcCompositeProfileDef, IfcCompressorType, IfcCondenserType, IfcCondition, IfcConditionCriterion, IfcConic, IfcConnectedFaceSet, IfcConnectionCurveGeometry, IfcConnectionGeometry, IfcConnectionPointEccentricity, IfcConnectionPointGeometry, IfcConnectionPortGeometry, IfcConnectionSurfaceGeometry, IfcConstraint, IfcConstraintAggregationRelationship, IfcConstraintClassificationRelationship, IfcConstraintRelationship, IfcConstructionEquipmentResource, IfcConstructionMaterialResource, IfcConstructionProductResource, IfcConstructionResource, IfcContextDependentUnit, IfcControl, IfcControllerType, IfcConversionBasedUnit, IfcCooledBeamType, IfcCoolingTowerType, IfcCoordinatedUniversalTimeOffset, IfcCostItem, IfcCostSchedule, IfcCostValue, IfcCovering, IfcCoveringType, IfcCraneRailAShapeProfileDef, IfcCraneRailFShapeProfileDef, IfcCrewResource, IfcCsgPrimitive3D, IfcCsgSolid, IfcCurrencyRelationship, IfcCurtainWall, IfcCurtainWallType, IfcCurve, IfcCurveBoundedPlane, IfcCurveStyle, IfcCurveStyleFont, IfcCurveStyleFontAndScaling, IfcCurveStyleFontPattern, IfcDamperType, IfcDateAndTime, IfcDefinedSymbol, IfcDerivedProfileDef, IfcDerivedUnit, IfcDerivedUnitElement, IfcDiameterDimension, IfcDimensionCalloutRelationship, IfcDimensionCurve, IfcDimensionCurveDirectedCallout, IfcDimensionCurveTerminator, IfcDimensionPair, IfcDimensionalExponents, IfcDirection, IfcDiscreteAccessory, IfcDiscreteAccessoryType, IfcDistributionChamberElement, IfcDistributionChamberElementType, IfcDistributionControlElement, IfcDistributionControlElementType, IfcDistributionElement, IfcDistributionElementType, IfcDistributionFlowElement, IfcDistributionFlowElementType, IfcDistributionPort, IfcDocumentElectronicFormat, IfcDocumentInformation, IfcDocumentInformationRelationship, IfcDocumentReference, IfcDoor, IfcDoorLiningProperties, IfcDoorPanelProperties, IfcDoorStyle, IfcDraughtingCallout, IfcDraughtingCalloutRelationship, IfcDraughtingPreDefinedColour, IfcDraughtingPreDefinedCurveFont, IfcDraughtingPreDefinedTextFont, IfcDuctFittingType, IfcDuctSegmentType, IfcDuctSilencerType, IfcEdge, IfcEdgeCurve, IfcEdgeFeature, IfcEdgeLoop, IfcElectricApplianceType, IfcElectricDistributionPoint, IfcElectricFlowStorageDeviceType, IfcElectricGeneratorType, IfcElectricHeaterType, IfcElectricMotorType, IfcElectricTimeControlType, IfcElectricalBaseProperties, IfcElectricalCircuit, IfcElectricalElement, IfcElement, IfcElementAssembly, IfcElementComponent, IfcElementComponentType, IfcElementQuantity, IfcElementType, IfcElementarySurface, IfcEllipse, IfcEllipseProfileDef, IfcEnergyConversionDevice, IfcEnergyConversionDeviceType, IfcEnergyProperties, IfcEnvironmentalImpactValue, IfcEquipmentElement, IfcEquipmentStandard, IfcEvaporativeCoolerType, IfcEvaporatorType, IfcExtendedMaterialProperties, IfcExternalReference, IfcExternallyDefinedHatchStyle, IfcExternallyDefinedSurfaceStyle, IfcExternallyDefinedSymbol, IfcExternallyDefinedTextFont, IfcExtrudedAreaSolid, IfcFace, IfcFaceBasedSurfaceModel, IfcFaceBound, IfcFaceOuterBound, IfcFaceSurface, IfcFacetedBrep, IfcFacetedBrepWithVoids, IfcFailureConnectionCondition, IfcFanType, IfcFastener, IfcFastenerType, IfcFeatureElement, IfcFeatureElementAddition, IfcFeatureElementSubtraction, IfcFillAreaStyle, IfcFillAreaStyleHatching, IfcFillAreaStyleTileSymbolWithStyle, IfcFillAreaStyleTiles, IfcFilterType, IfcFireSuppressionTerminalType, IfcFlowController, IfcFlowControllerType, IfcFlowFitting, IfcFlowFittingType, IfcFlowInstrumentType, IfcFlowMeterType, IfcFlowMovingDevice, IfcFlowMovingDeviceType, IfcFlowSegment, IfcFlowSegmentType, IfcFlowStorageDevice, IfcFlowStorageDeviceType, IfcFlowTerminal, IfcFlowTerminalType, IfcFlowTreatmentDevice, IfcFlowTreatmentDeviceType, IfcFluidFlowProperties, IfcFooting, IfcFuelProperties, IfcFurnishingElement, IfcFurnishingElementType, IfcFurnitureStandard, IfcFurnitureType, IfcGasTerminalType, IfcGeneralMaterialProperties, IfcGeneralProfileProperties, IfcGeometricCurveSet, IfcGeometricRepresentationContext, IfcGeometricRepresentationItem, IfcGeometricRepresentationSubContext, IfcGeometricSet, IfcGrid, IfcGridAxis, IfcGridPlacement, IfcGroup, IfcHalfSpaceSolid, IfcHeatExchangerType, IfcHumidifierType, IfcHygroscopicMaterialProperties, IfcIShapeProfileDef, IfcImageTexture, IfcInventory, IfcIrregularTimeSeries, IfcIrregularTimeSeriesValue, IfcJunctionBoxType, IfcLShapeProfileDef, IfcLaborResource, IfcLampType, IfcLibraryInformation, IfcLibraryReference, IfcLightDistributionData, IfcLightFixtureType, IfcLightIntensityDistribution, IfcLightSource, IfcLightSourceAmbient, IfcLightSourceDirectional, IfcLightSourceGoniometric, IfcLightSourcePositional, IfcLightSourceSpot, IfcLine, IfcLinearDimension, IfcLocalPlacement, IfcLocalTime, IfcLoop, IfcManifoldSolidBrep, IfcMappedItem, IfcMaterial, IfcMaterialClassificationRelationship, IfcMaterialDefinitionRepresentation, IfcMaterialLayer, IfcMaterialLayerSet, IfcMaterialLayerSetUsage, IfcMaterialList, IfcMaterialProperties, IfcMeasureWithUnit, IfcMechanicalConcreteMaterialProperties, IfcMechanicalFastener, IfcMechanicalFastenerType, IfcMechanicalMaterialProperties, IfcMechanicalSteelMaterialProperties, IfcMember, IfcMemberType, IfcMetric, IfcMonetaryUnit, IfcMotorConnectionType, IfcMove, IfcNamedUnit, IfcObject, IfcObjectDefinition, IfcObjectPlacement, IfcObjective, IfcOccupant, IfcOffsetCurve2D, IfcOffsetCurve3D, IfcOneDirectionRepeatFactor, IfcOpenShell, IfcOpeningElement, IfcOpticalMaterialProperties, IfcOrderAction, IfcOrganization, IfcOrganizationRelationship, IfcOrientedEdge, IfcOutletType, IfcOwnerHistory, IfcParameterizedProfileDef, IfcPath, IfcPerformanceHistory, IfcPermeableCoveringProperties, IfcPermit, IfcPerson, IfcPersonAndOrganization, IfcPhysicalComplexQuantity, IfcPhysicalQuantity, IfcPhysicalSimpleQuantity, IfcPile, IfcPipeFittingType, IfcPipeSegmentType, IfcPixelTexture, IfcPlacement, IfcPlanarBox, IfcPlanarExtent, IfcPlane, IfcPlate, IfcPlateType, IfcPoint, IfcPointOnCurve, IfcPointOnSurface, IfcPolyLoop, IfcPolygonalBoundedHalfSpace, IfcPolyline, IfcPort, IfcPostalAddress, IfcPreDefinedColour, IfcPreDefinedCurveFont, IfcPreDefinedDimensionSymbol, IfcPreDefinedItem, IfcPreDefinedPointMarkerSymbol, IfcPreDefinedSymbol, IfcPreDefinedTerminatorSymbol, IfcPreDefinedTextFont, IfcPresentationLayerAssignment, IfcPresentationLayerWithStyle, IfcPresentationStyle, IfcPresentationStyleAssignment, IfcProcedure, IfcProcess, IfcProduct, IfcProductDefinitionShape, IfcProductRepresentation, IfcProductsOfCombustionProperties, IfcProfileDef, IfcProfileProperties, IfcProject, IfcProjectOrder, IfcProjectOrderRecord, IfcProjectionCurve, IfcProjectionElement, IfcProperty, IfcPropertyBoundedValue, IfcPropertyConstraintRelationship, IfcPropertyDefinition, IfcPropertyDependencyRelationship, IfcPropertyEnumeratedValue, IfcPropertyEnumeration, IfcPropertyListValue, IfcPropertyReferenceValue, IfcPropertySet, IfcPropertySetDefinition, IfcPropertySingleValue, IfcPropertyTableValue, IfcProtectiveDeviceType, IfcProxy, IfcPumpType, IfcQuantityArea, IfcQuantityCount, IfcQuantityLength, IfcQuantityTime, IfcQuantityVolume, IfcQuantityWeight, IfcRadiusDimension, IfcRailing, IfcRailingType, IfcRamp, IfcRampFlight, IfcRampFlightType, IfcRationalBezierCurve, IfcRectangleHollowProfileDef, IfcRectangleProfileDef, IfcRectangularPyramid, IfcRectangularTrimmedSurface, IfcReferencesValueDocument, IfcRegularTimeSeries, IfcReinforcementBarProperties, IfcReinforcementDefinitionProperties, IfcReinforcingBar, IfcReinforcingElement, IfcReinforcingMesh, IfcRelAggregates, IfcRelAssigns, IfcRelAssignsTasks, IfcRelAssignsToActor, IfcRelAssignsToControl, IfcRelAssignsToGroup, IfcRelAssignsToProcess, IfcRelAssignsToProduct, IfcRelAssignsToProjectOrder, IfcRelAssignsToResource, IfcRelAssociates, IfcRelAssociatesAppliedValue, IfcRelAssociatesApproval, IfcRelAssociatesClassification, IfcRelAssociatesConstraint, IfcRelAssociatesDocument, IfcRelAssociatesLibrary, IfcRelAssociatesMaterial, IfcRelAssociatesProfileProperties, IfcRelConnects, IfcRelConnectsElements, IfcRelConnectsPathElements, IfcRelConnectsPortToElement, IfcRelConnectsPorts, IfcRelConnectsStructuralActivity, IfcRelConnectsStructuralElement, IfcRelConnectsStructuralMember, IfcRelConnectsWithEccentricity, IfcRelConnectsWithRealizingElements, IfcRelContainedInSpatialStructure, IfcRelCoversBldgElements, IfcRelCoversSpaces, IfcRelDecomposes, IfcRelDefines, IfcRelDefinesByProperties, IfcRelDefinesByType, IfcRelFillsElement, IfcRelFlowControlElements, IfcRelInteractionRequirements, IfcRelNests, IfcRelOccupiesSpaces, IfcRelOverridesProperties, IfcRelProjectsElement, IfcRelReferencedInSpatialStructure, IfcRelSchedulesCostItems, IfcRelSequence, IfcRelServicesBuildings, IfcRelSpaceBoundary, IfcRelVoidsElement, IfcRelationship, IfcRelaxation, IfcRepresentation, IfcRepresentationContext, IfcRepresentationItem, IfcRepresentationMap, IfcResource, IfcRevolvedAreaSolid, IfcRibPlateProfileProperties, IfcRightCircularCone, IfcRightCircularCylinder, IfcRoof, IfcRoot, IfcRoundedEdgeFeature, IfcRoundedRectangleProfileDef, IfcSIUnit, IfcSanitaryTerminalType, IfcScheduleTimeControl, IfcSectionProperties, IfcSectionReinforcementProperties, IfcSectionedSpine, IfcSensorType, IfcServiceLife, IfcServiceLifeFactor, IfcShapeAspect, IfcShapeModel, IfcShapeRepresentation, IfcShellBasedSurfaceModel, IfcSimpleProperty, IfcSite, IfcSlab, IfcSlabType, IfcSlippageConnectionCondition, IfcSolidModel, IfcSoundProperties, IfcSoundValue, IfcSpace, IfcSpaceHeaterType, IfcSpaceProgram, IfcSpaceThermalLoadProperties, IfcSpaceType, IfcSpatialStructureElement, IfcSpatialStructureElementType, IfcSphere, IfcStackTerminalType, IfcStair, IfcStairFlight, IfcStairFlightType, IfcStructuralAction, IfcStructuralActivity, IfcStructuralAnalysisModel, IfcStructuralConnection, IfcStructuralConnectionCondition, IfcStructuralCurveConnection, IfcStructuralCurveMember, IfcStructuralCurveMemberVarying, IfcStructuralItem, IfcStructuralLinearAction, IfcStructuralLinearActionVarying, IfcStructuralLoad, IfcStructuralLoadGroup, IfcStructuralLoadLinearForce, IfcStructuralLoadPlanarForce, IfcStructuralLoadSingleDisplacement, IfcStructuralLoadSingleDisplacementDistortion, IfcStructuralLoadSingleForce, IfcStructuralLoadSingleForceWarping, IfcStructuralLoadStatic, IfcStructuralLoadTemperature, IfcStructuralMember, IfcStructuralPlanarAction, IfcStructuralPlanarActionVarying, IfcStructuralPointAction, IfcStructuralPointConnection, IfcStructuralPointReaction, IfcStructuralProfileProperties, IfcStructuralReaction, IfcStructuralResultGroup, IfcStructuralSteelProfileProperties, IfcStructuralSurfaceConnection, IfcStructuralSurfaceMember, IfcStructuralSurfaceMemberVarying, IfcStructuredDimensionCallout, IfcStyleModel, IfcStyledItem, IfcStyledRepresentation, IfcSubContractResource, IfcSubedge, IfcSurface, IfcSurfaceCurveSweptAreaSolid, IfcSurfaceOfLinearExtrusion, IfcSurfaceOfRevolution, IfcSurfaceStyle, IfcSurfaceStyleLighting, IfcSurfaceStyleRefraction, IfcSurfaceStyleRendering, IfcSurfaceStyleShading, IfcSurfaceStyleWithTextures, IfcSurfaceTexture, IfcSweptAreaSolid, IfcSweptDiskSolid, IfcSweptSurface, IfcSwitchingDeviceType, IfcSymbolStyle, IfcSystem, IfcSystemFurnitureElementType, IfcTShapeProfileDef, IfcTable, IfcTableRow, IfcTankType, IfcTask, IfcTelecomAddress, IfcTendon, IfcTendonAnchor, IfcTerminatorSymbol, IfcTextLiteral, IfcTextLiteralWithExtent, IfcTextStyle, IfcTextStyleFontModel, IfcTextStyleForDefinedFont, IfcTextStyleTextModel, IfcTextStyleWithBoxCharacteristics, IfcTextureCoordinate, IfcTextureCoordinateGenerator, IfcTextureMap, IfcTextureVertex, IfcThermalMaterialProperties, IfcTimeSeries, IfcTimeSeriesReferenceRelationship, IfcTimeSeriesSchedule, IfcTimeSeriesValue, IfcTopologicalRepresentationItem, IfcTopologyRepresentation, IfcTransformerType, IfcTransportElement, IfcTransportElementType, IfcTrapeziumProfileDef, IfcTrimmedCurve, IfcTubeBundleType, IfcTwoDirectionRepeatFactor, IfcTypeObject, IfcTypeProduct, IfcUShapeProfileDef, IfcUnitAssignment, IfcUnitaryEquipmentType, IfcValveType, IfcVector, IfcVertex, IfcVertexBasedTextureMap, IfcVertexLoop, IfcVertexPoint, IfcVibrationIsolatorType, IfcVirtualElement, IfcVirtualGridIntersection, IfcWall, IfcWallStandardCase, IfcWallType, IfcWasteTerminalType, IfcWaterProperties, IfcWindow, IfcWindowLiningProperties, IfcWindowPanelProperties, IfcWindowStyle, IfcWorkControl, IfcWorkPlan, IfcWorkSchedule, IfcZShapeProfileDef, IfcZone, ALL + } Enum; + Enum FromString(const std::string& s); + std::string ToString(Enum v); +} + +} + +#endif \ No newline at end of file diff --git a/src/ifcparse/IfcGeom.h b/src/ifcparse/IfcGeom.h index dcb8185ca3..e729542494 100644 --- a/src/ifcparse/IfcGeom.h +++ b/src/ifcparse/IfcGeom.h @@ -1,67 +1,50 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + #ifndef IFCGEOM_H #define IFCGEOM_H -#include "../ifcparse/IfcParse.h" -#include "../ifcparse/IfcTypes.h" #include #include -#include -#include #include #include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - #include #include #include +#include +#include -#include -#include -#include -#include -#include +#include "../ifcparse/IfcParse.h" +#include "../ifcparse/IfcUtil.h" -#include -#include - -#include - -#define SCALE 1000.0f - -/* -namespace IFCgeom { - bool convert( Entity* L, gp_Vec*& CC ); - bool convert( Entity* L, gp_Pnt*& CC ); - bool convert( Entity* L, gp_Vec2d*& CC ); - bool convert( Entity* L, gp_Pnt2d*& CC ); - bool convert ( Entity* L, gp_Ax3*& ax3 ); - bool convert ( Entity* L, gp_Trsf*& trsf ); - bool convert ( Entity* L, gp_Trsf2d*& trsf ); - bool convert ( Entity* L, gp_Pln*& pln ); - bool convert ( const Entity* L, TopoDS_Wire& wire, int& count ); - bool convert( const Entity* L, TopoDS_Face& face); - bool convert( const Entity* L, TopoDS_Shape& shape); - bool move ( const Entity* L, gp_Trsf& trsf ); - bool move ( const Entity* L, TopoDS_Shape& shape ); - bool hasopenings( const Entity* L ); - bool open( const Entity* L, TopoDS_Shape& shape ); - bool open( const Entity* L, TopoDS_Shape& shape, gp_Trsf trsf2 ); +namespace IfcGeom { + bool convert_wire_to_face(const TopoDS_Wire& wire, TopoDS_Face& face); + bool convert_shape(const SHARED_PTR& L, TopoDS_Shape& result); + bool convert_wire(const SHARED_PTR& L, TopoDS_Wire& result); + bool convert_curve(const SHARED_PTR& L, Handle(Geom_Curve)& result); + bool convert_face(const SHARED_PTR& L, TopoDS_Face& result); + bool convert_openings(const Ifc2x3::IfcProduct::ptr& L, const Ifc2x3::IfcRelVoidsElement::list& openings, TopoDS_Shape& result, const gp_Trsf& trsf); + bool profile_helper(int numVerts, float* verts, int numFillets, int* filletIndices, float* filletRadii, gp_Trsf2d trsf, TopoDS_Face& face); + namespace Cache { + void Purge(); + void PurgeShapeCache(); + } +#include "IfcRegisterGeomHeader.h" } -*/ -#endif \ No newline at end of file +#endif diff --git a/src/ifcparse/IfcGeomCurves.cpp b/src/ifcparse/IfcGeomCurves.cpp new file mode 100644 index 0000000000..4c553cc60d --- /dev/null +++ b/src/ifcparse/IfcGeomCurves.cpp @@ -0,0 +1,116 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +/******************************************************************************** + * * + * Implementations of the various conversion functions defined in IfcRegister.h * + * * + ********************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include + +#include "../ifcparse/IfcGeom.h" + +bool IfcGeom::convert(const Ifc2x3::IfcCircle::ptr& l, Handle(Geom_Curve)& curve) { + const float r = l->Radius() * Ifc::LengthUnit; + if ( r <= 0.0f ) { return false; } + gp_Trsf trsf; + Ifc2x3::IfcAxis2Placement placement = l->Position(); + if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) { + IfcGeom::convert(reinterpret_pointer_cast(placement),trsf); + } else { + gp_Trsf2d trsf2d; + IfcGeom::convert(reinterpret_pointer_cast(placement),trsf2d); + trsf = trsf2d; + } + gp_Ax2 ax = gp_Ax2().Transformed(trsf); + curve = new Geom_Circle(ax, r); + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcEllipse::ptr& l, Handle(Geom_Curve)& curve) { + float x = l->SemiAxis1() * Ifc::LengthUnit; + float y = l->SemiAxis2() * Ifc::LengthUnit; + if ( x == 0.0f || y == 0.0f || y > x ) { return false; } + gp_Trsf trsf; + Ifc2x3::IfcAxis2Placement placement = l->Position(); + if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) { + IfcGeom::convert(reinterpret_pointer_cast(placement),trsf); + } else { + gp_Trsf2d trsf2d; + IfcGeom::convert(reinterpret_pointer_cast(placement),trsf2d); + trsf = trsf2d; + } + gp_Ax2 ax = gp_Ax2().Transformed(trsf); + curve = new Geom_Ellipse(ax, x, y); + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcLine::ptr& l, Handle(Geom_Curve)& curve) { + gp_Pnt pnt;gp_Vec vec; + IfcGeom::convert(l->Pnt(),pnt); + IfcGeom::convert(l->Dir(),vec); + curve = new Geom_Line(pnt,vec); + return true; +} \ No newline at end of file diff --git a/src/ifcparse/IfcGeomFaces.cpp b/src/ifcparse/IfcGeomFaces.cpp new file mode 100644 index 0000000000..e5e9763df3 --- /dev/null +++ b/src/ifcparse/IfcGeomFaces.cpp @@ -0,0 +1,266 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +/******************************************************************************** + * * + * Implementations of the various conversion functions defined in IfcRegister.h * + * * + ********************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include + +#include "../ifcparse/IfcGeom.h" + +bool IfcGeom::convert(const Ifc2x3::IfcFace::ptr& l, TopoDS_Face& face) { + Ifc2x3::IfcFaceBound::list bounds = l->Bounds(); + Ifc2x3::IfcFaceBound::it it = bounds->begin(); + Ifc2x3::IfcLoop::ptr loop = (*it)->Bound(); + TopoDS_Wire wire; + if ( ! IfcGeom::convert_wire(loop,wire) ) return false; + BRepBuilderAPI_MakeFace mf (wire); + BRepBuilderAPI_FaceError er = mf.Error(); + if ( er == BRepBuilderAPI_NotPlanar ) { + ShapeFix_ShapeTolerance FTol; + FTol.SetTolerance(wire, 0.01, TopAbs_WIRE); + mf = BRepBuilderAPI_MakeFace(wire, false); + er = mf.Error(); + } + if ( er != BRepBuilderAPI_FaceDone ) return false; + if ( bounds->Size() == 1 ) { + face = mf.Face(); + return true; + } + for( ++it; it != bounds->end(); ++ it) { + Ifc2x3::IfcLoop::ptr loop = (*it)->Bound(); + TopoDS_Wire wire; + if ( ! IfcGeom::convert_wire(loop,wire) ) return false; + mf.Add(wire); + } + if ( mf.IsDone() ) { + ShapeFix_Shape sfs(mf.Face()); + sfs.Perform(); + face = TopoDS::Face(sfs.Shape()); + return true; + } else { + return false; + } +} +bool IfcGeom::convert(const Ifc2x3::IfcArbitraryClosedProfileDef::ptr& l, TopoDS_Face& face) { + TopoDS_Wire wire; + if ( ! IfcGeom::convert_wire(l->OuterCurve(),wire) ) return false; + return IfcGeom::convert_wire_to_face(wire,face); +} +bool IfcGeom::convert(const Ifc2x3::IfcArbitraryProfileDefWithVoids::ptr& l, TopoDS_Face& face) { + TopoDS_Wire profile; + if ( ! IfcGeom::convert_wire(l->OuterCurve(),profile) ) return false; + BRepBuilderAPI_MakeFace mf(profile); + Ifc2x3::IfcCurve::list voids = l->InnerCurves(); + for( Ifc2x3::IfcCurve::it it = voids->begin(); it != voids->end(); ++ it ) { + TopoDS_Wire hole; + if ( IfcGeom::convert_wire(*it,hole) ) { + mf.Add(hole); + } + } + ShapeFix_Shape sfs(mf.Face()); + sfs.Perform(); + face = TopoDS::Face(sfs.Shape()); + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcRectangleProfileDef::ptr& l, TopoDS_Face& face) { + const float x = l->XDim() / 2.0f * Ifc::LengthUnit; + const float y = l->YDim() / 2.0f * Ifc::LengthUnit; + + if ( x == 0.0f || y == 0.0f ) { + Ifc::LogMessage("Notice","Skipping zero sized profile:",l->entity); + return false; + } + + gp_Trsf2d trsf2d; + IfcGeom::convert(l->Position(),trsf2d); + float coords[8] = {-x,-y,x,-y,x,y,-x,y}; + return IfcGeom::profile_helper(4,coords,0,0,0,trsf2d,face); +} +bool IfcGeom::convert(const Ifc2x3::IfcIShapeProfileDef::ptr& l, TopoDS_Face& face) { + const float x = l->OverallWidth() / 2.0f * Ifc::LengthUnit; + const float y = l->OverallDepth() / 2.0f * Ifc::LengthUnit; + const float d1 = l->WebThickness() / 2.0f * Ifc::LengthUnit; + const float d2 = l->FlangeThickness() * Ifc::LengthUnit; + bool doFillet = l->hasFilletRadius(); + float f; + if ( doFillet ) { + f = l->FilletRadius() * Ifc::LengthUnit; + } + + if ( x == 0.0f || y == 0.0f || d1 == 0.0f || d2 == 0.0f ) { + Ifc::LogMessage("Notice","Skipping zero sized profile:",l->entity); + return false; + } + + gp_Trsf2d trsf2d; + IfcGeom::convert(l->Position(),trsf2d); + + float coords[24] = {-x,-y,x,-y,x,-y+d2,d1,-y+d2,d1,y-d2,x,y-d2,x,y,-x,y,-x,y-d2,-d1,y-d2,-d1,-y+d2,-x,-y+d2}; + int fillets[4] = {3,4,9,10}; + float radii[4] = {f,f,f,f}; + return IfcGeom::profile_helper(12,coords,doFillet ? 4 : 0,fillets,radii,trsf2d,face); +} +bool IfcGeom::convert(const Ifc2x3::IfcCShapeProfileDef::ptr& l, TopoDS_Face& face) { + const float x = l->Depth() / 2.0f * Ifc::LengthUnit; + const float y = l->Width() / 2.0f * Ifc::LengthUnit; + const float d1 = l->WallThickness() * Ifc::LengthUnit; + const float d2 = l->Girth() * Ifc::LengthUnit; + bool doFillet = l->hasInternalFilletRadius(); + float f1,f2; + if ( doFillet ) { + f1 = l->InternalFilletRadius() * Ifc::LengthUnit; + f2 = f1 + d1; + } + + if ( x == 0.0f || y == 0.0f || d1 == 0.0f || d2 == 0.0f ) { + Ifc::LogMessage("Notice","Skipping zero sized profile:",l->entity); + return false; + } + + gp_Trsf2d trsf2d; + IfcGeom::convert(l->Position(),trsf2d); + + float coords[24] = {-x,-y,x,-y,x,-y+d2,x-d1,-y+d2,x-d1,-y+d1,-x+d1,-y+d1,-x+d1,y-d1,x-d1,y-d1,x-d1,y-d2,x,y-d2,x,y,-x,y}; + int fillets[8] = {0,1,4,5,6,7,10,11}; + float radii[8] = {f2,f2,f1,f1,f1,f1,f2,f2}; + return IfcGeom::profile_helper(12,coords,doFillet ? 8 : 0,fillets,radii,trsf2d,face); +} +bool IfcGeom::convert(const Ifc2x3::IfcLShapeProfileDef::ptr& l, TopoDS_Face& face) { + const float y = l->Depth() / 2.0f * Ifc::LengthUnit; + const float x = l->Width() / 2.0f * Ifc::LengthUnit; + const float d = l->Thickness() * Ifc::LengthUnit; + bool doEdgeFillet = l->hasEdgeRadius(); + bool doFillet = l->hasFilletRadius(); + float f1 = 0.0f; + float f2 = 0.0f; + if (doFillet) { + f1 = l->FilletRadius() * Ifc::LengthUnit; + } + if ( doEdgeFillet) { + f2 = l->EdgeRadius() * Ifc::LengthUnit; + } + if ( x == 0.0f || y == 0.0f || d == 0.0f ) { + Ifc::LogMessage("Notice","Skipping zero sized profile:",l->entity); + return false; + } + + gp_Trsf2d trsf2d; + IfcGeom::convert(l->Position(),trsf2d); + + float coords[12] = {-x,-y,x,-y,x,-y+d,-x+d,-y+d,-x+d,y,-x,y}; + int fillets[3] = {2,3,4}; + float radii[3] = {f2,f1,f2}; + return IfcGeom::profile_helper(6,coords,doFillet ? 3 : 0,fillets,radii,trsf2d,face); +} +bool IfcGeom::convert(const Ifc2x3::IfcCircleProfileDef::ptr& l, TopoDS_Face& face) { + const float r = l->Radius() * Ifc::LengthUnit; + if ( r == 0.0f ) { + Ifc::LogMessage("Notice","Skipping zero sized profile:",l->entity); + return false; + } + + gp_Trsf2d trsf; + IfcGeom::convert(l->Position(),trsf); + + BRepBuilderAPI_MakeWire w; + gp_Ax2 ax = gp_Ax2().Transformed(trsf); + Handle(Geom_Circle) circle = new Geom_Circle(ax, r); + TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(circle); + w.Add(edge); + return IfcGeom::convert_wire_to_face(w,face); +} +bool IfcGeom::convert(const Ifc2x3::IfcCircleHollowProfileDef::ptr& l, TopoDS_Face& face) { + const float r = l->Radius() * Ifc::LengthUnit; + const float t = l->WallThickness() * Ifc::LengthUnit; + + if ( r == 0.0f || t == 0.0f ) { + Ifc::LogMessage("Notice","Skipping zero sized profile:",l->entity); + return false; + } + + gp_Trsf2d trsf; + IfcGeom::convert(l->Position(),trsf); + gp_Ax2 ax = gp_Ax2().Transformed(trsf); + + BRepBuilderAPI_MakeWire outer; + Handle(Geom_Circle) outerCircle = new Geom_Circle(ax, r); + outer.Add(BRepBuilderAPI_MakeEdge(outerCircle)); + BRepBuilderAPI_MakeFace mf(outer.Wire(), false); + + BRepBuilderAPI_MakeWire inner; + Handle(Geom_Circle) innerCirlce = new Geom_Circle(ax, r-t); + inner.Add(BRepBuilderAPI_MakeEdge(innerCirlce)); + mf.Add(inner); + + ShapeFix_Shape sfs(mf.Face()); + sfs.Perform(); + face = TopoDS::Face(sfs.Shape()); + return true; +} \ No newline at end of file diff --git a/src/ifcparse/IfcGeomFunctions.cpp b/src/ifcparse/IfcGeomFunctions.cpp new file mode 100644 index 0000000000..0957798f62 --- /dev/null +++ b/src/ifcparse/IfcGeomFunctions.cpp @@ -0,0 +1,142 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +/******************************************************************************** + * * + * Implementations of the various conversion functions defined in IfcGeom.h * + * * + ********************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include + +#include "../ifcparse/IfcGeom.h" + +bool IfcGeom::convert_openings(const Ifc2x3::IfcProduct::ptr& entity, + const Ifc2x3::IfcRelVoidsElement::list& openings, TopoDS_Shape& result, const gp_Trsf& trsf2) { + for ( Ifc2x3::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) { + Ifc2x3::IfcRelVoidsElement::ptr v = *it; + Ifc2x3::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement(); + if ( fes->is(Ifc2x3::Type::IfcOpeningElement) ) { + gp_Trsf trsf; + IfcGeom::convert(fes->ObjectPlacement(),trsf); + trsf.PreMultiply(trsf2.Inverted()); + Ifc2x3::IfcProductRepresentation::ptr prodrep = fes->Representation(); + if ( prodrep->is(Ifc2x3::Type::IfcProductDefinitionShape) ) { + Ifc2x3::IfcProductDefinitionShape::ptr pds = reinterpret_pointer_cast(prodrep); + Ifc2x3::IfcRepresentation::list reps = pds->Representations(); + for ( Ifc2x3::IfcRepresentation::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) { + TopoDS_Shape s; + IfcGeom::convert_shape(*it2,s); + s.Move(trsf); + result = BRepAlgoAPI_Cut(result,s); + } + } + } + } + return true; +} +bool IfcGeom::convert_wire_to_face(const TopoDS_Wire& wire, TopoDS_Face& face) { + BRepBuilderAPI_MakeFace mf(wire, false); + BRepBuilderAPI_FaceError er = mf.Error(); + if ( er == BRepBuilderAPI_NotPlanar ) { + ShapeFix_ShapeTolerance FTol; + FTol.SetTolerance(wire, 0.01, TopAbs_WIRE); + mf = BRepBuilderAPI_MakeFace(wire, false); + er = mf.Error(); + } + if ( er != BRepBuilderAPI_FaceDone ) return false; + face = mf.Face(); + return true; +} +bool IfcGeom::profile_helper(int numVerts, float* verts, int numFillets, int* filletIndices, float* filletRadii, gp_Trsf2d trsf, TopoDS_Face& face) { + TopoDS_Vertex* vertices = new TopoDS_Vertex[numVerts]; + + for ( int i = 0; i < numVerts; i ++ ) { + gp_XY xy (verts[2*i],verts[2*i+1]); + trsf.Transforms(xy); + vertices[i] = BRepBuilderAPI_MakeVertex(gp_Pnt(xy.X(),xy.Y(),0.0f)); + } + + BRepBuilderAPI_MakeWire w; + for ( int i = 0; i < numVerts; i ++ ) + w.Add(BRepBuilderAPI_MakeEdge(vertices[i],vertices[(i+1)%numVerts])); + + IfcGeom::convert_wire_to_face(w.Wire(),face); + + if ( numFillets ) { + BRepFilletAPI_MakeFillet2d fillet (face); + for ( int i = 0; i < numFillets; i ++ ) { + const float radius = filletRadii[i]; + if ( radius < 1e-7 ) continue; + fillet.AddFillet(vertices[filletIndices[i]],radius); + } + fillet.Build(); + face = TopoDS::Face(fillet.Shape()); + } + + delete[] vertices; + return true; +} \ No newline at end of file diff --git a/src/ifcparse/IfcGeomHelpers.cpp b/src/ifcparse/IfcGeomHelpers.cpp new file mode 100644 index 0000000000..b6e86a016d --- /dev/null +++ b/src/ifcparse/IfcGeomHelpers.cpp @@ -0,0 +1,211 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +/******************************************************************************** + * * + * Implementations of the various conversion functions defined in IfcRegister.h * + * * + ********************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include + +#include "../ifcparse/IfcGeom.h" + + +namespace IfcGeom { + namespace Cache { +#include "IfcRegisterCreateCache.h" + } +} +#define IN_CACHE(T,E,t,e) std::map::const_iterator it = Cache::T.find(E->entity->id());\ + if ( it != Cache::T.end() ) { e = it->second; return true; } +#define CACHE(T,E,e) Cache::T[E->entity->id()] = e; + +bool IfcGeom::convert(const Ifc2x3::IfcCartesianPoint::ptr& l, gp_Pnt& point) { + IN_CACHE(IfcCartesianPoint,l,gp_Pnt,point) + std::vector xyz = l->Coordinates(); + point = gp_Pnt( + xyz.size() ? (xyz[0]*Ifc::LengthUnit) : 0.0f, + xyz.size() > 1 ? (xyz[1]*Ifc::LengthUnit) : 0.0f, + xyz.size() > 2 ? (xyz[2]*Ifc::LengthUnit) : 0.0f + ); + CACHE(IfcCartesianPoint,l,point) + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcDirection::ptr& l, gp_Dir& dir) { + IN_CACHE(IfcDirection,l,gp_Dir,dir) + std::vector xyz = l->DirectionRatios(); + dir = gp_Dir( + xyz.size() ? xyz[0] : 0.0f, + xyz.size() > 1 ? xyz[1] : 0.0f, + xyz.size() > 2 ? xyz[2] : 0.0f + ); + CACHE(IfcDirection,l,dir) + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcVector::ptr& l, gp_Vec& v) { + IN_CACHE(IfcVector,l,gp_Vec,v) + gp_Dir d; + IfcGeom::convert(l->Orientation(),d); + v = l->Magnitude() * Ifc::LengthUnit * d; + CACHE(IfcVector,l,v) + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement3D::ptr& l, gp_Trsf& trsf) { + IN_CACHE(IfcAxis2Placement3D,l,gp_Trsf,trsf) + gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection; + IfcGeom::convert(l->Location(),o); + bool hasRef = l->hasRefDirection(); + if ( l->hasAxis() ) IfcGeom::convert(l->Axis(),axis); + if ( hasRef ) IfcGeom::convert(l->RefDirection(),refDirection); + gp_Ax3 ax3; + if ( hasRef ) ax3 = gp_Ax3(o,axis,refDirection); + else ax3 = gp_Ax3(o,axis); + trsf.SetTransformation(ax3, gp_Ax3(gp_Pnt(),gp_Dir(0,0,1),gp_Dir(1,0,0))); + CACHE(IfcAxis2Placement3D,l,trsf) + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator3D::ptr& l, gp_Trsf& trsf) { + IN_CACHE(IfcCartesianTransformationOperator3D,l,gp_Trsf,trsf) + gp_Pnt origin; + IfcGeom::convert(l->LocalOrigin(),origin); + gp_Dir axis1 (1.,0.,0.); + gp_Dir axis2 (0.,1.,0.); + gp_Dir axis3; + if ( l->hasAxis1() ) IfcGeom::convert(l->Axis1(),axis1); + if ( l->hasAxis2() ) IfcGeom::convert(l->Axis2(),axis2); + if ( l->hasAxis3() ) IfcGeom::convert(l->Axis3(),axis3); + else axis3 = axis1.Crossed(axis2); + const gp_Ax3 ax3 (origin,axis3,axis1); + trsf.SetTransformation(ax3); + if ( l->hasScale() ) trsf.SetScaleFactor(l->Scale()); + CACHE(IfcCartesianTransformationOperator3D,l,trsf) + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator2D::ptr& l, gp_Trsf2d& trsf) { + IN_CACHE(IfcCartesianTransformationOperator2D,l,gp_Trsf2d,trsf) + gp_Pnt origin; + IfcGeom::convert(l->LocalOrigin(),origin); + gp_Dir axis1 (1.,0.,0.); + if ( l->hasAxis1() ) IfcGeom::convert(l->Axis1(),axis1); + const gp_Ax2d ax2d (gp_Pnt2d(origin.X(),origin.Y()),gp_Dir2d(axis1.X(),axis1.Y())); + trsf.SetTransformation(ax2d); + if ( l->hasScale() ) trsf.SetScaleFactor(l->Scale()); + CACHE(IfcCartesianTransformationOperator2D,l,trsf) + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcPlane::ptr& pln, gp_Pln& plane) { + IN_CACHE(IfcPlane,pln,gp_Pln,plane) + Ifc2x3::IfcAxis2Placement3D::ptr l = pln->Position(); + gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection; + IfcGeom::convert(l->Location(),o); + bool hasRef = l->hasRefDirection(); + if ( l->hasAxis() ) IfcGeom::convert(l->Axis(),axis); + if ( hasRef ) IfcGeom::convert(l->RefDirection(),refDirection); + gp_Ax3 ax3; + if ( hasRef ) ax3 = gp_Ax3(o,axis,refDirection); + else ax3 = gp_Ax3(o,axis); + plane = gp_Pln(ax3); + CACHE(IfcPlane,pln,plane) + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement2D::ptr& l, gp_Trsf2d& trsf) { + IN_CACHE(IfcAxis2Placement2D,l,gp_Trsf2d,trsf) + gp_Pnt P; gp_Dir V (1,0,0); + IfcGeom::convert(l->Location(),P); + if ( l->hasRefDirection() ) + IfcGeom::convert(l->RefDirection(),V); + + gp_Ax2d axis(gp_Pnt2d(P.X(),P.Y()),gp_Dir2d(V.X(),V.Y())); + trsf.SetTransformation(axis,gp_Ax2d()); + CACHE(IfcAxis2Placement2D,l,trsf) + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcObjectPlacement::ptr& l, gp_Trsf& trsf) { + IN_CACHE(IfcObjectPlacement,l,gp_Trsf,trsf) + if ( ! l->is(Ifc2x3::Type::IfcLocalPlacement) ) return false; + Ifc2x3::IfcLocalPlacement::ptr current = reinterpret_pointer_cast(l); + while (1) { + gp_Trsf trsf2; + Ifc2x3::IfcAxis2Placement relplacement = current->RelativePlacement(); + if ( relplacement->is(Ifc2x3::Type::IfcAxis2Placement3D) ) { + IfcGeom::convert(reinterpret_pointer_cast(relplacement),trsf2); + trsf.PreMultiply(trsf2); + } + if ( current->hasPlacementRelTo() ) { + Ifc2x3::IfcObjectPlacement::ptr relto = current->PlacementRelTo(); + if ( relto->is(Ifc2x3::Type::IfcLocalPlacement) ) + current = reinterpret_pointer_cast(current->PlacementRelTo()); + else break; + } else break; + } + CACHE(IfcObjectPlacement,l,trsf) + return true; +} +void IfcGeom::Cache::Purge() { +#include "IfcRegisterCreateCache.h" + IfcGeom::Cache::PurgeShapeCache(); +} \ No newline at end of file diff --git a/src/ifcparse/IfcGeomObjects.cpp b/src/ifcparse/IfcGeomObjects.cpp index 717f3b956f..97402dc73a 100644 --- a/src/ifcparse/IfcGeomObjects.cpp +++ b/src/ifcparse/IfcGeomObjects.cpp @@ -35,8 +35,6 @@ #include "../ifcparse/IfcGeomObjects.h" #include "../ifcparse/IfcGeom.h" -#include "../ifcparse/IfcEnum.h" -#include "../ifcparse/IfcTypes.h" // Welds vertices that belong to different faces int IfcGeomObjects::IfcMesh::addvert(gp_Pnt p) { @@ -47,7 +45,7 @@ int IfcGeomObjects::IfcMesh::addvert(gp_Pnt p) { verts.push_back(X); verts.push_back(Y); verts.push_back(Z); - int i = welds.size(); + int i = (int) welds.size(); welds[key] = i; return i; } @@ -60,7 +58,7 @@ IfcGeomObjects::IfcMesh::IfcMesh(int i, TopoDS_Shape s) { BRepTools::Clean(s); BRepMesh::Mesh(s,0.001f); } catch(...) { - std::cout << "[Error] Failed to triangulate IFC Entity #" << i << std::endl; + Ifc::LogMessage("Error","Failed to triangulate mesh"); return; } TopExp_Explorer exp; @@ -117,21 +115,21 @@ IfcGeomObjects::IfcGeomObject::IfcGeomObject( const std::string& n, const std::s } // A container and iterator for IfcShapeRepresentations -IfcEntities shapereps; -IfcParse::Entities::it outer; +Ifc2x3::IfcShapeRepresentation::list shapereps; +Ifc2x3::IfcShapeRepresentation::it outer; // The triangulated shape is stored globally because it can be used by multiple IfcBuildingElements IfcGeomObjects::IfcMesh* shape; // The compound shape is stored globally because multiple IfcShapeRepresentations // can have IfcBuildingElements with different IfcOpeningElements -TopoDS_Compound shapes; +TopoDS_Shape shapes; // The object is fetched beforehand to be positive an entity actually exists IfcGeomObjects::IfcGeomObject* currentGeomObj; // A container and iterator for IfcBuildingElements for the current IfcShapeRepresentation referenced by *outer -IfcEntities entities; -IfcParse::Entities::it inner; +Ifc2x3::IfcProduct::list entities; +Ifc2x3::IfcProduct::it inner; bool use_world_coords; int done; @@ -150,74 +148,61 @@ void _nextShape() { // Returns the current IfcGeomObject* IfcGeomObjects::IfcGeomObject* _get() { while ( true ) { - IfcEntity shaperep; + Ifc2x3::IfcShapeRepresentation::ptr shaperep; + + // Have we reached the end of our list of representations? if ( outer == shapereps->end() ) { shapereps.reset(); return 0; } shaperep = *outer; + + // Has the list of IfcProducts for this representation been initialized? if ( ! entities ) { - const std::string arg1 = *(*shaperep)[1]; - if ( arg1 != "Body" ) { + if ( shaperep->RepresentationIdentifier() != "Body" ) { _nextShape(); continue; } -#ifdef _DEBUG - std::cout << shaperep->toString() << std::endl; -#endif - // Find the IfcBuildingElements that refer to the current IfcShapeRepresentation - entities = shaperep->parents(IfcSchema::Enum::IfcProductDefinitionShape)->parents(); - entities->push(shaperep->parents(IfcSchema::Enum::IfcProductRepresentation)->parents()); // 2x2 compatibility - entities->push(shaperep->parents(IfcSchema::Enum::IfcRepresentationMap)->parents(IfcSchema::Enum::IfcMappedItem) - ->parents(IfcSchema::Enum::IfcShapeRepresentation,1,"Body")->parents(IfcSchema::Enum::IfcProductDefinitionShape)->parents()); - entities->push(shaperep->parents(IfcSchema::Enum::IfcRepresentationMap)->parents(IfcSchema::Enum::IfcMappedItem) - ->parents(IfcSchema::Enum::IfcShapeRepresentation,1,"Body")->parents(IfcSchema::Enum::IfcProductRepresentation)->parents()); + Ifc2x3::IfcProductRepresentation::list prodreps = shaperep->OfProductRepresentation(); + entities = Ifc2x3::IfcProduct::list( new IfcTemplatedEntityList() ); + for ( Ifc2x3::IfcProductRepresentation::it it = prodreps->begin(); it != prodreps->end(); ++it ) { + if ( (*it)->is(Ifc2x3::Type::IfcProductDefinitionShape) ) { + Ifc2x3::IfcProductDefinitionShape::ptr pds = reinterpret_pointer_cast(*it); + entities->push(pds->ShapeOfProduct()); + } + } + // Does this representation have any IfcProducts? if ( ! entities->Size() ) { _nextShape(); continue; } inner = entities->begin(); } + // Have we reached the end of our list of IfcProducts? if ( inner == entities->end() ) { _nextShape(); continue; } + // Has the TopoDS_Shape been created for this representation? if ( shapes.IsNull() ) { - BRep_Builder builder; - builder.MakeCompound (shapes); - - bool hasShapes = false; - IfcEntities l = ((IfcSchema::ShapeRepresentation*)shaperep.get())->Shapes(); - for( IfcParse::Entities::it it = l->begin(); it != l->end(); ++ it ) { - const IfcEntity ifcshape = *it; - if ( ifcshape->type == IfcSchema::Enum::IfcMappedItem ) continue; - TopoDS_Shape ss; - if ( IfcGeom::convert_shape(ifcshape,ss) && ! ss.IsNull() ) { - builder.Add(shapes,ss); - hasShapes = true; -#ifdef _DEBUG - std::cout << ifcshape->toString() << std::endl; -#endif - } - } - if ( ! hasShapes || shapes.IsNull() ) { + if ( !IfcGeom::convert_shape(shaperep,shapes) ) { _nextShape(); continue; } } + Ifc2x3::IfcProduct::ptr entity = *inner; + const std::string guid = entity->GlobalId(); - IfcSchema::BuildingElement* entity = (IfcSchema::BuildingElement*)(*inner).get(); -#ifdef _DEBUG - std::cout << entity->toString() << std::endl; -#endif - const std::string guid = entity->Guid(); gp_Trsf trsf; try { - IfcGeom::convert((IfcSchema::LocalPlacement*)(entity->Placement().get()),trsf); - } catch( IfcParse::IfcException& e ) {std::cout << "[Error] " << e.what() << std::endl; _nextShape(); } - IfcEntities openings = IfcEntities(); - if ( entity->type != IfcSchema::Enum::IfcOpeningElement ) { - openings = entity->parents(IfcSchema::Enum::IfcRelVoidsElement); + IfcGeom::convert(entity->ObjectPlacement(),trsf); + } catch (...) {} + + // Does the IfcElement have any IfcOpenings? + Ifc2x3::IfcRelVoidsElement::list openings = Ifc2x3::IfcRelVoidsElement::list(); + if ( entity->is(Ifc2x3::Type::IfcElement) ) { + Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast(entity); + openings = element->HasOpenings(); } if ( (openings && openings->Size()) || use_world_coords ) { @@ -225,19 +210,21 @@ IfcGeomObjects::IfcGeomObject* _get() { TopoDS_Shape temp_shape (shapes); try { if (openings && openings->Size()) IfcGeom::convert_openings(entity,openings,temp_shape,trsf); - } catch( IfcParse::IfcException& e ) {std::cout << "[Warning] " << e.what() << std::endl; } - catch(StdFail_NotDone&) { std::cout << "[Error] Unknown modelling processing openings for:" << std::endl << entity->toString() << std::endl; } + } catch( IfcParse::IfcException& e ) {Ifc::LogMessage("Warning",e.what()); } + catch(...) { Ifc::LogMessage("Error","Error processing openings for:",entity->entity); } if ( use_world_coords ) { - shape = new IfcGeomObjects::IfcMesh(shaperep->id,temp_shape.Moved(trsf)); + shape = new IfcGeomObjects::IfcMesh(shaperep->entity->id(),temp_shape.Moved(trsf)); trsf = gp_Trsf(); } else { - shape = new IfcGeomObjects::IfcMesh(shaperep->id,temp_shape); + shape = new IfcGeomObjects::IfcMesh(shaperep->entity->id(),temp_shape); } } else if ( ! shape ) { - shape = new IfcGeomObjects::IfcMesh(shaperep->id,shapes); + shape = new IfcGeomObjects::IfcMesh(shaperep->entity->id(),shapes); } - return new IfcGeomObjects::IfcGeomObject(guid, entity->Datatype(), trsf, shape); + + return new IfcGeomObjects::IfcGeomObject(guid, Ifc2x3::Type::ToString(entity->type()), trsf, shape); } + } extern bool IfcGeomObjects::Next() { @@ -249,6 +236,7 @@ extern bool IfcGeomObjects::Next() { if ( ! currentGeomObj ) { delete shape; Ifc::Dispose(); + IfcGeom::Cache::Purge(); return false; } else { return true; @@ -257,11 +245,12 @@ extern bool IfcGeomObjects::Next() { extern const IfcGeomObjects::IfcGeomObject* IfcGeomObjects::Get() { return currentGeomObj; } -extern bool IfcGeomObjects::Init(char* fn, bool world_coords) { +extern bool IfcGeomObjects::Init(char* fn, bool world_coords, std::ostream* log) { + if ( log ) Ifc::SetOutput(log); use_world_coords = world_coords; if ( !Ifc::Init(fn) ) return false; - shapereps = Ifc::EntitiesByType(IfcSchema::Enum::IfcShapeRepresentation); + shapereps = Ifc::EntitiesByType(); if ( ! shapereps ) return false; outer = shapereps->begin(); @@ -272,7 +261,7 @@ extern bool IfcGeomObjects::Init(char* fn, bool world_coords) { done = 0; total = shapereps->Size(); - return 1; + return true; } extern int IfcGeomObjects::Progress() { return 100 * done / total; diff --git a/src/ifcparse/IfcGeomObjects.h b/src/ifcparse/IfcGeomObjects.h index 00f84a6d41..8749c3c786 100644 --- a/src/ifcparse/IfcGeomObjects.h +++ b/src/ifcparse/IfcGeomObjects.h @@ -97,7 +97,7 @@ namespace IfcGeomObjects { IfcGeomObject( const std::string& n, const std::string& t, gp_Trsf trsf, IfcMesh* m ); }; - extern bool Init(char* fn, bool world_coords = false); + extern bool Init(char* fn, bool world_coords = false, std::ostream* log= 0); extern const IfcGeomObject* Get(); extern bool Next(); extern int Progress(); diff --git a/src/ifcparse/IfcGeomShapes.cpp b/src/ifcparse/IfcGeomShapes.cpp new file mode 100644 index 0000000000..5b83b73b70 --- /dev/null +++ b/src/ifcparse/IfcGeomShapes.cpp @@ -0,0 +1,231 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +/******************************************************************************** + * * + * Implementations of the various conversion functions defined in IfcRegister.h * + * * + ********************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include + +#include "../ifcparse/IfcGeom.h" + +bool IfcGeom::convert(const Ifc2x3::IfcExtrudedAreaSolid::ptr& l, TopoDS_Shape& shape) { + TopoDS_Face face; + if ( ! IfcGeom::convert_face(l->SweptArea(),face) ) return false; + const float height = l->Depth() * Ifc::LengthUnit; + gp_Trsf trsf; + IfcGeom::convert(l->Position(),trsf); + + gp_Dir dir; + convert(l->ExtrudedDirection(),dir); + + shape = BRepPrimAPI_MakePrism(face,height*dir); + shape.Move(trsf); + return ! shape.IsNull(); +} +bool IfcGeom::convert(const Ifc2x3::IfcFacetedBrep::ptr& l, TopoDS_Shape& shape) { + return IfcGeom::convert_shape(l->Outer(),shape); +} +bool IfcGeom::convert(const Ifc2x3::IfcFaceBasedSurfaceModel::ptr& l, TopoDS_Shape& shape) { + Ifc2x3::IfcConnectedFaceSet::list facesets = l->FbsmFaces(); + BRep_Builder builder; + TopoDS_Compound c; + builder.MakeCompound(c); + for( Ifc2x3::IfcConnectedFaceSet::it it = facesets->begin(); it != facesets->end(); ++ it ) { + TopoDS_Shape s; + if ( IfcGeom::convert_shape(*it,s) ) { + builder.Add(c,s); + } + } + shape = c; + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcHalfSpaceSolid::ptr& l, TopoDS_Shape& shape) { + Ifc2x3::IfcSurface::ptr surface = l->BaseSurface(); + if ( ! surface->is(Ifc2x3::Type::IfcPlane) ) { + // Not implemented + return false; + } + gp_Pln pln; + IfcGeom::convert(reinterpret_pointer_cast(surface),pln); + gp_Pnt pnt = pln.Location(); + bool reverse = l->AgreementFlag(); + if ( l->is(Ifc2x3::Type::IfcPolygonalBoundedHalfSpace) ) reverse = !reverse; + if ( reverse ) pnt.Translate(-pln.Axis().Direction()); + else pnt.Translate(pln.Axis().Direction()); + shape = BRepPrimAPI_MakeHalfSpace(BRepBuilderAPI_MakeFace(pln),pnt).Solid(); + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcPolygonalBoundedHalfSpace::ptr& l, TopoDS_Shape& shape) { + TopoDS_Shape halfspace; + if ( ! IfcGeom::convert(reinterpret_pointer_cast(l),halfspace) ) return false; + TopoDS_Wire wire; + if ( ! IfcGeom::convert_wire(l->PolygonalBoundary(),wire) ) return false; + gp_Trsf trsf; + convert(l->Position(),trsf); + TopoDS_Shape extrusion = BRepPrimAPI_MakePrism(BRepBuilderAPI_MakeFace(wire),gp_Vec(0,0,20000.0)); + gp_Trsf down; down.SetTranslation(gp_Vec(0,0,-10000.0)); + extrusion.Move(trsf*down); + shape = BRepAlgoAPI_Cut(extrusion,halfspace); + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcShellBasedSurfaceModel::ptr& l, TopoDS_Shape& shape) { + IfcUtil::IfcAbstractSelect::list shells = l->SbsmBoundary(); + BRep_Builder builder; + TopoDS_Compound c; + builder.MakeCompound(c); + for( IfcUtil::IfcAbstractSelect::it it = shells->begin(); it != shells->end(); ++ it ) { + TopoDS_Shape s; + if ( IfcGeom::convert_shape(*it,s) ) { + builder.Add(c,s); + } + } + shape = c; + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcBooleanClippingResult::ptr& l, TopoDS_Shape& shape) { + TopoDS_Shape s1, s2; + if ( ! IfcGeom::convert_shape(l->FirstOperand(),s1) ) + return false; + if ( ! IfcGeom::convert_shape(l->SecondOperand(),s2) ) + return false; + shape = BRepAlgoAPI_Cut(s1,s2); + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcClosedShell::ptr& l, TopoDS_Shape& shape) { + if ( ! IfcGeom::convert((Ifc2x3::IfcConnectedFaceSet::ptr)l,shape) ) return false; + try { + ShapeFix_Solid solid; + solid.LimitTolerance(0.01); + shape = solid.SolidFromShell(TopoDS::Shell(shape)); + } catch(...) {} + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcConnectedFaceSet::ptr& l, TopoDS_Shape& shape) { + BRepOffsetAPI_Sewing builder; + builder.SetTolerance(0.01); + Ifc2x3::IfcFace::list faces = l->CfsFaces(); + bool facesAdded = false; + for( Ifc2x3::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) { + TopoDS_Face face; + if ( IfcGeom::convert_face(*it,face) ) { + builder.Add(face); + facesAdded = true; + } else { + Ifc::LogMessage("Warning","Invalid face:",(*it)->entity); + } + } + if ( ! facesAdded ) return false; + builder.Perform(); + shape = builder.SewedShape(); + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcMappedItem::ptr& l, TopoDS_Shape& shape) { + gp_Trsf trsf1; + Ifc2x3::IfcCartesianTransformationOperator::ptr transform = l->MappingTarget(); + if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator2DnonUniform) || + transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator3DnonUniform) ) { + // Not implemented + return false; + } else if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator3D) ) { + IfcGeom::convert(reinterpret_pointer_cast(transform),trsf1); + } else if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator2D) ) { + gp_Trsf2d trsf1_2d; + IfcGeom::convert(reinterpret_pointer_cast(transform),trsf1_2d); + trsf1 = trsf1_2d; + } + Ifc2x3::IfcRepresentationMap::ptr map = l->MappingSource(); + Ifc2x3::IfcAxis2Placement placement = map->MappingOrigin(); + gp_Trsf trsf2; + if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) { + IfcGeom::convert(reinterpret_pointer_cast(placement),trsf2); + } else { + gp_Trsf2d trsf2_2d; + IfcGeom::convert(reinterpret_pointer_cast(placement),trsf2_2d); + trsf2 = trsf2_2d; + } + if ( ! IfcGeom::convert_shape(map->MappedRepresentation(),shape) ) return false; + shape.Move(trsf2 * trsf1); + return !shape.IsNull(); +} +bool IfcGeom::convert(const Ifc2x3::IfcShapeRepresentation::ptr& l, TopoDS_Shape& shape) { + Ifc2x3::IfcRepresentationItem::list items = l->Items(); + if ( ! items->Size() ) return false; + BRep_Builder builder; + TopoDS_Compound c; + builder.MakeCompound(c); + for ( Ifc2x3::IfcRepresentationItem::it it = items->begin(); it != items->end(); ++ it ) { + TopoDS_Shape s; + if ( ! IfcGeom::convert_shape(*it,s)) continue; + builder.Add(c,s); + } + shape = c; + return !shape.IsNull(); +} \ No newline at end of file diff --git a/src/ifcparse/IfcGeomWires.cpp b/src/ifcparse/IfcGeomWires.cpp new file mode 100644 index 0000000000..7aed769864 --- /dev/null +++ b/src/ifcparse/IfcGeomWires.cpp @@ -0,0 +1,176 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +/******************************************************************************** + * * + * Implementations of the various conversion functions defined in IfcRegister.h * + * * + ********************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include + +#include "../ifcparse/IfcGeom.h" + +bool IfcGeom::convert(const Ifc2x3::IfcCompositeCurve::ptr& l, TopoDS_Wire& wire) { + Ifc2x3::IfcCompositeCurveSegment::list segments = l->Segments(); + BRepBuilderAPI_MakeWire w; + for( Ifc2x3::IfcCompositeCurveSegment::it it = segments->begin(); it != segments->end(); ++ it ) { + const Ifc2x3::IfcCurve::ptr curve = (*it)->ParentCurve(); + TopoDS_Wire wire2; + if ( ! IfcGeom::convert_wire(curve,wire2) ) continue; + ShapeFix_ShapeTolerance FTol; + FTol.SetTolerance(wire2, 0.01, TopAbs_WIRE); + w.Add(wire2); + if ( w.Error() != BRepBuilderAPI_WireDone ) { + Ifc::LogMessage("Error","Failed to join curve segments:",l->entity); + return false; + } + } + wire = w.Wire(); + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcTrimmedCurve::ptr& l, TopoDS_Wire& wire) { + Ifc2x3::IfcCurve::ptr basis_curve = l->BasisCurve(); + bool isConic = basis_curve->is(Ifc2x3::Type::IfcConic); + float parameterFactor = isConic ? Ifc::PlaneAngleUnit : Ifc::LengthUnit; + Handle(Geom_Curve) curve; + if ( ! IfcGeom::convert_curve(basis_curve,curve) ) return false; + bool trim_cartesian = l->MasterRepresentation() == Ifc2x3::IfcTrimmingPreference::CARTESIAN; + IfcUtil::IfcAbstractSelect::list trims1 = l->Trim1(); + IfcUtil::IfcAbstractSelect::list trims2 = l->Trim2(); + bool trimmed1 = false; + bool trimmed2 = false; + float flt1; + gp_Pnt pnt1; + BRepBuilderAPI_MakeWire w; + for ( IfcUtil::IfcAbstractSelect::it it = trims1->begin(); it != trims1->end(); it ++ ) { + const IfcUtil::IfcAbstractSelect::ptr i = *it; + if ( i->is(Ifc2x3::Type::IfcCartesianPoint) && trim_cartesian ) { + IfcGeom::convert(reinterpret_pointer_cast(i), pnt1 ); + trimmed1 = true; + } else if ( i->is(Ifc2x3::Type::IfcParameterValue) ) { + const float value = *reinterpret_pointer_cast(i)->wrappedValue(); + flt1 = value * parameterFactor; + trimmed1 = true; + } + } + for ( IfcUtil::IfcAbstractSelect::it it = trims2->begin(); it != trims2->end(); it ++ ) { + const IfcUtil::IfcAbstractSelect::ptr i = *it; + if ( i->is(Ifc2x3::Type::IfcCartesianPoint) && trim_cartesian && trimmed1 ) { + gp_Pnt pnt2; + IfcGeom::convert(reinterpret_pointer_cast(i), pnt2 ); + BRepBuilderAPI_MakeEdge e (curve,pnt1,pnt2); + w.Add(e.Edge()); + trimmed2 = true; + } else if ( i->is(Ifc2x3::Type::IfcParameterValue) && trimmed1 ) { + const float value = *reinterpret_pointer_cast(i)->wrappedValue(); + float flt2 = value * parameterFactor; + BRepBuilderAPI_MakeEdge e (curve,flt1,flt2); + w.Add(e.Edge()); + trimmed2 = true; + } + } + if ( trimmed2 ) wire = w.Wire(); + return trimmed2; +} +bool IfcGeom::convert(const Ifc2x3::IfcPolyline::ptr& l, TopoDS_Wire& result) { + Ifc2x3::IfcCartesianPoint::list points = l->Points(); + + BRepBuilderAPI_MakeWire w; + gp_Pnt P1;gp_Pnt P2; + for( Ifc2x3::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) { + IfcGeom::convert(*it,P2); + if ( it != points->begin() && ( P1.X() != P2.X() || P1.Y() != P2.Y() || P1.Z() != P2.Z() ) ) + w.Add(BRepBuilderAPI_MakeEdge(P1,P2)); + P1 = P2; + } + + result = w.Wire(); + return true; +} +bool IfcGeom::convert(const Ifc2x3::IfcPolyLoop::ptr& l, TopoDS_Wire& result) { + Ifc2x3::IfcCartesianPoint::list points = l->Polygon(); + + BRepBuilderAPI_MakeWire w; + gp_Pnt P1;gp_Pnt P2;gp_Pnt F; + int count = 0; + for( Ifc2x3::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) { + IfcGeom::convert(*it,P2); + if ( it != points->begin() && ( P1.X() != P2.X() || P1.Y() != P2.Y() || P1.Z() != P2.Z() ) ) { + w.Add(BRepBuilderAPI_MakeEdge(P1,P2)); + count ++; + } else if ( ! count ) F = P2; + P1 = P2; + } + if ( P1.X() != F.X() || P1.Y() != F.Y() || P1.Z() != F.Z() ) { + w.Add(BRepBuilderAPI_MakeEdge(P1,F)); + count ++; + } + if ( count < 3 ) return false; + + result = w.Wire(); + return true; +} \ No newline at end of file diff --git a/src/ifcparse/IfcParse.cpp b/src/ifcparse/IfcParse.cpp index 85d80e7884..149f4e8edc 100644 --- a/src/ifcparse/IfcParse.cpp +++ b/src/ifcparse/IfcParse.cpp @@ -17,9 +17,11 @@ * * ********************************************************************************/ +#include +#include + #include "../ifcparse/IfcParse.h" -#include "../ifcparse/IfcEnum.h" -#include "../ifcparse/IfcTypes.h" +#include "../ifcparse/IfcUtil.h" using namespace IfcParse; @@ -30,7 +32,7 @@ File::File(const std::string& fn) { eof = false; stream.open(fn.c_str(),std::ios_base::binary); stream.seekg(0,std::ios_base::end); - size = stream.tellg(); + size = (unsigned int) stream.tellg(); stream.seekg(0,std::ios_base::beg); buffer = new char[size < BUF_SIZE ? size : BUF_SIZE]; ptr = 0; @@ -55,7 +57,7 @@ void File::ReadBuffer(bool inc) { eof = stream.eof(); if ( eof ) return; stream.read(buffer,size < BUF_SIZE ? size : BUF_SIZE); - len = stream.gcount(); + len = (unsigned int) stream.gcount(); eof = len == 0; ptr = 0; } @@ -252,7 +254,7 @@ TokenArgument::TokenArgument(Token t) { token = t; } -EntityArgument::EntityArgument(EntityPtr e) { +EntityArgument::EntityArgument(IfcUtil::IfcSchemaEntity e) { entity = e; } @@ -269,7 +271,9 @@ ArgumentList::ArgumentList(Tokens* t, std::vector& ids) { if ( TokenFunc::isIdentifier(next) ) ids.push_back(TokenFunc::asInt(next)); if ( TokenFunc::isDatatype(next) ) { Ifc::file->Seek(TokenFunc::Offset(next)); - EntityPtr entity = EntityPtr(new Entity(0,t,ids,true)); + EntityPtr e = EntityPtr(new Entity(0,t)); + e->Load(ids,true); + IfcUtil::IfcSchemaEntity entity = Ifc2x3::SchemaEntity(e); Push ( ArgumentPtr(new EntityArgument(entity)) ); } else { Push ( ArgumentPtr(new TokenArgument(next)) ); @@ -289,18 +293,43 @@ ArgumentList::operator int() const { throw IfcException("Argument is not an inte ArgumentList::operator bool() const { throw IfcException("Argument is not a boolean"); } ArgumentList::operator float() const { throw IfcException("Argument is not a number"); } ArgumentList::operator std::string() const { throw IfcException("Argument is not a string"); } -ArgumentList::operator EntityPtr() const { throw IfcException("Argument is not an IFC type"); } -ArgumentList::operator EntitiesPtr() const { - EntitiesPtr l (new Entities()); +ArgumentList::operator std::vector() const { + std::vector r; + std::vector::const_iterator it; + for ( it = list.begin(); it != list.end(); ++ it ) { + r.push_back(**it); + } + return r; +} +ArgumentList::operator std::vector() const { + std::vector r; + std::vector::const_iterator it; + for ( it = list.begin(); it != list.end(); ++ it ) { + r.push_back(**it); + } + return r; +} +ArgumentList::operator std::vector() const { + std::vector r; + std::vector::const_iterator it; + for ( it = list.begin(); it != list.end(); ++ it ) { + r.push_back(**it); + } + return r; +} +ArgumentList::operator IfcUtil::IfcSchemaEntity() const { throw IfcException("Argument is not an IFC type"); } +ArgumentList::operator SHARED_PTR() const { throw IfcException("Argument is not an IFC type"); } +ArgumentList::operator IfcEntities() const { + IfcEntities l ( new IfcEntityList() ); std::vector::const_iterator it; for ( it = list.begin(); it != list.end(); ++ it ) { // FIXME: account for $ - const EntityPtr entity = **it; + const IfcUtil::IfcSchemaEntity entity = **it; l->push(entity); } return l; } -unsigned int ArgumentList::Size() const { return list.size(); } +unsigned int ArgumentList::Size() const { return (unsigned int) list.size(); } ArgumentPtr ArgumentList::operator [] (unsigned int i) const { if ( i >= list.size() ) throw IfcException("Argument index out of range"); @@ -316,6 +345,7 @@ std::string ArgumentList::toString() const { ss << ")"; return ss.str(); } +bool ArgumentList::isNull() const { return false; } // // Functions for casting the TokenArgument to other types @@ -324,12 +354,16 @@ TokenArgument::operator int() const { return TokenFunc::asInt(token); } TokenArgument::operator bool() const { return TokenFunc::asBool(token); } TokenArgument::operator float() const { return TokenFunc::asFloat(token); } TokenArgument::operator std::string() const { return TokenFunc::asString(token); } -TokenArgument::operator EntityPtr() const { return Ifc::EntityById(TokenFunc::asInt(token)); } -TokenArgument::operator EntitiesPtr() const { throw IfcException("Argument is not a list of entities"); } +TokenArgument::operator std::vector() const { throw IfcException("Argument is not a list of floats"); } +TokenArgument::operator std::vector() const { throw IfcException("Argument is not a list of ints"); } +TokenArgument::operator std::vector() const { throw IfcException("Argument is not a list of strings"); } +TokenArgument::operator IfcUtil::IfcSchemaEntity() const { return Ifc::EntityById(TokenFunc::asInt(token)); } +TokenArgument::operator SHARED_PTR() const { return SHARED_PTR( new IfcUtil::IfcEntitySelect(*this) ); } +TokenArgument::operator IfcEntities() const { throw IfcException("Argument is not a list of entities"); } unsigned int TokenArgument::Size() const { return 1; } ArgumentPtr TokenArgument::operator [] (unsigned int i) const { throw IfcException("Argument is not a list of arguments"); } std::string TokenArgument::toString() const { return TokenFunc::asString(token); } - +bool TokenArgument::isNull() const { return TokenFunc::isOperator(token,'$'); } // // Functions for casting the EntityArgument to other types // @@ -337,25 +371,27 @@ EntityArgument::operator int() const { throw IfcException("Argument is not an in EntityArgument::operator bool() const { throw IfcException("Argument is not a boolean"); } EntityArgument::operator float() const { throw IfcException("Argument is not a number"); } EntityArgument::operator std::string() const { throw IfcException("Argument is not a string"); } -EntityArgument::operator EntityPtr() const { return entity; } -EntityArgument::operator EntitiesPtr() const { throw IfcException("Argument is not a list of entities"); } +EntityArgument::operator std::vector() const { throw IfcException("Argument is not a list of floats"); } +EntityArgument::operator std::vector() const { throw IfcException("Argument is not a list of ints"); } +EntityArgument::operator std::vector() const { throw IfcException("Argument is not a list of strings"); } +EntityArgument::operator IfcUtil::IfcSchemaEntity() const { return entity; } +EntityArgument::operator SHARED_PTR() const { return SHARED_PTR( new IfcUtil::IfcArgumentSelect(entity->type(),entity->entity->getArgument(0)) ); } +EntityArgument::operator IfcEntities() const { throw IfcException("Argument is not a list of entities"); } unsigned int EntityArgument::Size() const { return 1; } ArgumentPtr EntityArgument::operator [] (unsigned int i) const { throw IfcException("Argument is not a list of arguments"); } -std::string EntityArgument::toString() const { return entity->toString(); } +std::string EntityArgument::toString() const { return entity->entity->toString(); } +bool EntityArgument::isNull() const { return false; } // // Reads an Entity from the list of Tokens -// If the type of the Entity is not known, the ArgumentList is not loaded // -Entity::Entity(unsigned int i, Tokens* t, std::vector& ids, bool parse) { +Entity::Entity(unsigned int i, Tokens* t) { Token datatype = t->Next(); if ( ! TokenFunc::isDatatype(datatype)) throw IfcException("Unexpected token while parsing entity"); - type = IfcSchema::Enum::FromString(TokenFunc::asString(datatype)); - id = i; + _type = Ifc2x3::Type::FromString(TokenFunc::asString(datatype)); + _id = i; args = ArgumentPtr(); offset = TokenFunc::Offset(datatype); - if ( (type != IfcSchema::Enum::IfcDontCare && type != IfcSchema::Enum::IfcUnknown) || parse ) - Load(ids, false); } // @@ -363,7 +399,7 @@ Entity::Entity(unsigned int i, Tokens* t, std::vector& ids, bool p // Entity::Entity(unsigned int i, Tokens* t, unsigned int o) { std::vector ids; - id = i; + _id = i; offset = o; Load(ids, true); } @@ -371,7 +407,7 @@ Entity::Entity(unsigned int i, Tokens* t, unsigned int o) { // // Access the Nth argument from the ArgumentList // -ArgumentPtr Entity::operator [] (unsigned int i) { +ArgumentPtr Entity::getArgument(unsigned int i) { if ( ! args ) { std::vector ids; Load(ids, true); @@ -386,8 +422,8 @@ void Entity::Load(std::vector& ids, bool seek) { if ( seek ) { Ifc::file->Seek(offset); Token datatype = Ifc::tokens->Next(); - if ( ! TokenFunc::isDatatype(datatype) ) throw IfcException("Unexpected token while parsing entity"); - type = IfcSchema::Enum::FromString(TokenFunc::asString(datatype)); + if ( ! TokenFunc::isDatatype(datatype)) throw IfcException("Unexpected token while parsing entity"); + _type = Ifc2x3::Type::FromString(TokenFunc::asString(datatype)); } Token open = Ifc::tokens->Next(); args = ArgumentPtr(new ArgumentList(Ifc::tokens, ids)); @@ -396,11 +432,15 @@ void Entity::Load(std::vector& ids, bool seek) { if ( ! TokenFunc::isOperator(semilocon,';') ) Ifc::file->Seek(old_offset); } +Ifc2x3::Type::Enum Entity::type() { + return _type; +} + // -// Returns a CamelCase string representation of the datatype as it is defined in IfcSchema.h +// Returns the CamelCase string representation of the datatype as it is defined in the schema // -std::string Entity::Datatype() const { - return IfcSchema::Enum::ToString(type); +std::string Entity::datatype() { + return Ifc2x3::Type::ToString(_type); } // @@ -413,67 +453,37 @@ std::string Entity::toString() { Load(ids, true); } std::stringstream ss; - ss << "#" << id << "=" << Datatype() << args->toString(); + ss << "#" << _id << "=" << datatype() << args->toString(); return ss.str(); } // // Returns the entities of type c that have this entity in their ArgumentList // -EntitiesPtr Entity::parents(IfcSchema::Enum::IfcTypes c) { - EntitiesPtr l = EntitiesPtr(new Entities()); - EntitiesPtr all = Ifc::EntitiesByReference(id); +IfcEntities Entity::getInverse(Ifc2x3::Type::Enum c) { + IfcEntities l = IfcEntities(new IfcEntityList()); + IfcEntities all = Ifc::EntitiesByReference(_id); if ( ! all ) return l; - for( Entities::it it = all->begin(); it != all->end();++ it ) { - if ( c == IfcSchema::Enum::ALL || (*it)->type == c ) { + for( IfcEntityList::it it = all->begin(); it != all->end();++ it ) { + if ( c == Ifc2x3::Type::ALL || (*it)->is(c) ) { l->push(*it); } } return l; } -EntitiesPtr Entity::parents(IfcSchema::Enum::IfcTypes c, int i, const std::string& a) { - EntitiesPtr l = EntitiesPtr(new Entities()); - EntitiesPtr all = parents(c); - for( Entities::it it = all->begin(); it != all->end();++ it ) { - const std::string s = *((**it)[i]); +IfcEntities Entity::getInverse(Ifc2x3::Type::Enum c, int i, const std::string& a) { + IfcEntities l = IfcEntities(new IfcEntityList()); + IfcEntities all = getInverse(c); + for( IfcEntityList::it it = all->begin(); it != all->end();++ it ) { + const std::string s = *(*it)->entity->getArgument(i); if ( s == a ) { l->push(*it); } } return l; } -void Entities::push(EntityPtr l) { - if ( l ) ls.push_back(l); -} -void Entities::push(EntitiesPtr l) { - for( it i = l->begin(); i != l->end(); ++i ) { - if ( *i ) ls.push_back(*i); - } -} -int Entities::Size() const { return ls.size(); } -Entities::it Entities::begin() { return ls.begin(); } -Entities::it Entities::end() { return ls.end(); } - -// -// Returns the entities of type c that have one of these entities in their ArgumentList -// -EntitiesPtr Entities::parents(IfcSchema::Enum::IfcTypes c) { - EntitiesPtr l = EntitiesPtr(new Entities()); - for( it i = begin(); i != end(); ++i ) { - l->push((*i)->parents(c)); - } - return l; -} -EntitiesPtr Entities::parents(IfcSchema::Enum::IfcTypes c, int ar, const std::string& a) { - EntitiesPtr l = EntitiesPtr(new Entities()); - for( it i = begin(); i != end(); ++i ) { - l->push((*i)->parents(c,ar,a)); - } - return l; -} -EntityPtr Entities::operator[] (int i) { - return ls[i]; -} +bool Entity::is(Ifc2x3::Type::Enum v) { return _type == v; } +unsigned int Entity::id() { return _id; } // // Parses the IFC file in fn @@ -488,33 +498,21 @@ bool Ifc::Init(const std::string& fn) { unsigned int currentId = 0; lastId = 0; int x = 0; - EntityPtr entity; - std::cout << "Scanning file..." << std::endl; + EntityPtr e; + IfcUtil::IfcSchemaEntity entity; + if ( log ) std::cout << "Scanning file..." << std::endl; while ( true ) { if ( currentId ) { - std::vector ids; - entity = EntityPtr(new Entity(currentId,tokens,ids)); - if ( !((++x)%1000) ) std::cout << "\r#" << currentId << " "; - if ( entity->type != IfcSchema::Enum::IfcDontCare && entity->type != IfcSchema::Enum::IfcUnknown) { - byid[currentId] = entity; - EntitiesPtr L = EntitiesByType(entity->type); - if ( L == 0 ) { - L = EntitiesPtr(new Entities()); - bytype[entity->type] = L; - } - L->push(entity); - for( std::vector::const_iterator it = ids.begin(); it != ids.end(); ++it ) { - const int arg_id = *it; - EntitiesPtr L = EntitiesByReference(arg_id); - if ( L == 0 ) { - L = EntitiesPtr(new Entities()); - byref[arg_id] = L; - } - L->push(entity); - } - } else { - offsets[currentId] = entity->offset; + e = EntityPtr(new Entity(currentId,tokens)); + entity = Ifc2x3::SchemaEntity(e); + if ( log && !((++x)%1000) ) std::cout << "\r#" << currentId << " " << std::flush; + IfcEntities L = EntitiesByType(entity->type()); + if ( L == 0 ) { + L = IfcEntities(new IfcEntityList()); + bytype[entity->type()] = L; } + L->push(entity); + byid[currentId] = entity; currentId = 0; } else token = tokens->Next(); if ( ! token ) break; @@ -523,9 +521,9 @@ bool Ifc::Init(const std::string& fn) { if ( TokenFunc::isOperator(token,'=') ) { currentId = id; } else { - EntitiesPtr L = EntitiesByReference(id); + IfcEntities L = EntitiesByReference(id); if ( L == 0 ) { - L = EntitiesPtr(new Entities()); + L = IfcEntities(new IfcEntityList()); byref[id] = L; } L->push(entity); @@ -534,61 +532,71 @@ bool Ifc::Init(const std::string& fn) { previous = token; } - std::cout << "\rDone! " << std::endl; + if ( log ) std::cout << "\rDone scanning file " << std::endl; - IfcEntity IfcUnitAssigment = *EntitiesByType(IfcSchema::Enum::IfcUnitAssignment)->begin(); - IfcEntities units = ((IfcSchema::UnitAssignment*)IfcUnitAssigment.get())->Units(); - Ifc::LengthUnit = 1.0f; - if ( units ) - for ( IfcParse::Entities::it it = units->begin(); it != units->end(); it ++ ) { - IfcEntity unit = *it; - float value = 1.0f; - std::string UnitType = ""; - if ( unit->type == IfcSchema::Enum::IfcConversionBasedUnit ) { - IfcSchema::ConversionBasedUnit* IfcConversionBasedUnit = (IfcSchema::ConversionBasedUnit*)(*it).get(); - IfcSchema::MeasureWithUnit* IfcMeasureWithUnit = (IfcSchema::MeasureWithUnit*)IfcConversionBasedUnit->ConversionFactor().get(); - try { - unit = IfcMeasureWithUnit->Unit(); - value = *((*IfcMeasureWithUnit->Value())[0]); - } catch (...) {} + Ifc2x3::IfcUnitAssignment::ptr unit_assignment = *EntitiesByType()->begin(); + IfcUtil::IfcAbstractSelect::list units = unit_assignment->Units(); + for ( IfcUtil::IfcAbstractSelect::it it = units->begin(); it != units->end(); ++ it ) { + const IfcUtil::IfcAbstractSelect::ptr base = *it; + Ifc2x3::IfcSIUnit::ptr unit = Ifc2x3::IfcSIUnit::ptr(); + float value = 1.0f; + if ( base->is(Ifc2x3::Type::IfcConversionBasedUnit) ) { + const Ifc2x3::IfcConversionBasedUnit::ptr u = reinterpret_pointer_cast(*it); + const Ifc2x3::IfcMeasureWithUnit::ptr u2 = u->ConversionFactor(); + Ifc2x3::IfcUnit u3 = u2->UnitComponent(); + if ( u3->is(Ifc2x3::Type::IfcSIUnit) ) { + unit = reinterpret_pointer_cast(u3); } - if ( unit->type == IfcSchema::Enum::IfcSIUnit ) { - IfcSchema::SIUnit* IfcSIUnit = (IfcSchema::SIUnit*)(*it).get(); - value *= UnitPrefixToValue(IfcSIUnit->UnitPrefix()); - UnitType = IfcSIUnit->UnitType(); + Ifc2x3::IfcValue v = u2->ValueComponent(); + if ( v->isSimpleType() ) { + IfcUtil::IfcArgumentSelect::ptr v2 = reinterpret_pointer_cast(v); + const float f = *v2->wrappedValue(); + value *= f; } - if ( UnitType == "LENGTHUNIT" ) { + } else if ( base->is(Ifc2x3::Type::IfcSIUnit) ) { + unit = reinterpret_pointer_cast(base); + } + if ( unit ) { + if ( unit->hasPrefix() ) { + value *= UnitPrefixToValue(unit->Prefix()); + } + Ifc2x3::IfcUnitEnum::IfcUnitEnum type = unit->UnitType(); + if ( type == Ifc2x3::IfcUnitEnum::LENGTHUNIT ) { Ifc::LengthUnit = value; - } else if ( UnitType == "PLANEANGLEUNIT" ) { + } else if ( type == Ifc2x3::IfcUnitEnum::PLANEANGLEUNIT ) { Ifc::PlaneAngleUnit = value; } } - return true; + } + return true; } -EntitiesPtr Ifc::EntitiesByType(IfcSchema::Enum::IfcTypes t) { +IfcEntities Ifc::EntitiesByType(Ifc2x3::Type::Enum t) { MapEntitiesByType::const_iterator it = bytype.find(t); - return (it == bytype.end()) ? EntitiesPtr() : it->second; + return (it == bytype.end()) ? IfcEntities() : it->second; } -EntitiesPtr Ifc::EntitiesByReference(int t) { +IfcEntities Ifc::EntitiesByReference(int t) { MapEntitiesByRef::const_iterator it = byref.find(t); - return (it == byref.end()) ? EntitiesPtr() : it->second; + return (it == byref.end()) ? IfcEntities() : it->second; } -EntityPtr Ifc::EntityById(int id) { +IfcUtil::IfcSchemaEntity Ifc::EntityById(int id) { MapEntityById::const_iterator it = byid.find(id); if ( it == byid.end() ) { MapOffsetById::const_iterator it2 = offsets.find(id); if ( it2 == offsets.end() ) throw IfcException("Entity not found"); const unsigned int offset = (*it2).second; - EntityPtr entity = EntityPtr(new Entity(id,Ifc::tokens,offset)); + EntityPtr e = EntityPtr(new Entity(id,Ifc::tokens,offset)); + IfcUtil::IfcSchemaEntity entity = Ifc2x3::SchemaEntity(e); byid[id] = entity; return entity; } return it->second; } + IfcException::IfcException(std::string e) { error = e; } IfcException::~IfcException() throw () {} const char* IfcException::what() const throw() { return error.c_str(); } + void Ifc::Dispose() { file->Close(); delete file; @@ -597,30 +605,37 @@ void Ifc::Dispose() { bytype.clear(); byid.clear(); byref.clear(); - IfcGeom::Cache::Purge(); } -float UnitPrefixToValue( const std::string& s ) { - if ( s == "EXA" ) return (float) 1e18; - else if ( s == "PETA" ) return (float) 1e15; - else if ( s == "TERA" ) return (float) 1e12; - else if ( s == "GIGA" ) return (float) 1e9; - else if ( s == "MEGA" ) return (float) 1e6; - else if ( s == "KILO" ) return (float) 1e3; - else if ( s == "HECTO" ) return (float) 1e2; - else if ( s == "DECA" ) return (float) 1; - else if ( s == "DECI" ) return (float) 1e-1; - else if ( s == "CENTI" ) return (float) 1e-2; - else if ( s == "MILLI" ) return (float) 1e-3; - else if ( s == "MICRO" ) return (float) 1e-6; - else if ( s == "NANO" ) return (float) 1e-9; - else if ( s == "PICO" ) return (float) 1e-12; - else if ( s == "FEMTO" ) return (float) 1e-15; - else if ( s == "ATTO" ) return (float) 1e-18; +float UnitPrefixToValue( Ifc2x3::IfcSIPrefix::IfcSIPrefix v ) { + if ( v == Ifc2x3::IfcSIPrefix::EXA ) return (float) 1e18; + else if ( v == Ifc2x3::IfcSIPrefix::PETA ) return (float) 1e15; + else if ( v == Ifc2x3::IfcSIPrefix::TERA ) return (float) 1e12; + else if ( v == Ifc2x3::IfcSIPrefix::GIGA ) return (float) 1e9; + else if ( v == Ifc2x3::IfcSIPrefix::MEGA ) return (float) 1e6; + else if ( v == Ifc2x3::IfcSIPrefix::KILO ) return (float) 1e3; + else if ( v == Ifc2x3::IfcSIPrefix::HECTO ) return (float) 1e2; + else if ( v == Ifc2x3::IfcSIPrefix::DECA ) return (float) 1; + else if ( v == Ifc2x3::IfcSIPrefix::DECI ) return (float) 1e-1; + else if ( v == Ifc2x3::IfcSIPrefix::CENTI ) return (float) 1e-2; + else if ( v == Ifc2x3::IfcSIPrefix::MILLI ) return (float) 1e-3; + else if ( v == Ifc2x3::IfcSIPrefix::MICRO ) return (float) 1e-6; + else if ( v == Ifc2x3::IfcSIPrefix::NANO ) return (float) 1e-9; + else if ( v == Ifc2x3::IfcSIPrefix::PICO ) return (float) 1e-12; + else if ( v == Ifc2x3::IfcSIPrefix::FEMTO ) return (float) 1e-15; + else if ( v == Ifc2x3::IfcSIPrefix::ATTO ) return (float) 1e-18; else return 1.0f; } +void Ifc::SetOutput(std::ostream* l) { log = l; } +void Ifc::LogMessage(const std::string& type, const std::string& message, const SHARED_PTR& entity) { + if ( log ) { + (*log) << "[" << type << "] " << message << std::endl; + if ( entity ) (*log) << entity->toString() << std::endl; + } +} File* Ifc::file = 0; +std::ostream* Ifc::log = 0; unsigned int Ifc::lastId = 0; Tokens* Ifc::tokens = 0; float Ifc::LengthUnit = 1.0f; diff --git a/src/ifcparse/IfcParse.h b/src/ifcparse/IfcParse.h index b8bc336085..46a5de2da5 100644 --- a/src/ifcparse/IfcParse.h +++ b/src/ifcparse/IfcParse.h @@ -20,7 +20,7 @@ /******************************************************************************** * * * This file provides functions for loading an IFC file into memory and access * - * its entities either by ID, by an IfcSchema::Enum::IfcType or by reference * + * its entities either by ID, by an Ifc2x3::Type or by reference * * * ********************************************************************************/ @@ -36,21 +36,9 @@ #include #include -// Pick a shared pointer implementation -#ifdef __GNUC__ -#include -#define SHARED_PTR std::tr1::shared_ptr -#else -#ifdef _MSC_VER -#include -#define SHARED_PTR std::tr1::shared_ptr -#else -#include -#define SHARED_PTR boost::shared_ptr -#endif -#endif - -#include "../ifcparse/IfcEnum.h" +#include "../ifcparse/SharedPointer.h" +#include "../ifcparse/IfcUtil.h" +#include "../ifcparse/Ifc2x3.h" const int BUF_SIZE = (32 * 1024 * 1024); @@ -128,26 +116,6 @@ namespace IfcParse { std::string TokenString(unsigned int offset); }; - class Argument; - typedef SHARED_PTR ArgumentPtr; - - // - // Base class of all kind of Arguments used in IFC entity defintions - // - class Argument { - protected: - public: - virtual operator int() const = 0; - virtual operator bool() const = 0; - virtual operator float() const = 0; - virtual operator std::string() const = 0; - virtual operator EntityPtr() const = 0; - virtual operator EntitiesPtr() const = 0; - virtual unsigned int Size() const = 0; - virtual ArgumentPtr operator [] (unsigned int i) const = 0; - virtual std::string toString() const = 0; - }; - // // Argument of type list, e.g. // #1=IfcDirection((1.,0.,0.)); @@ -163,11 +131,16 @@ namespace IfcParse { operator bool() const; operator float() const; operator std::string() const; - operator EntityPtr() const; - operator EntitiesPtr() const; + operator std::vector() const; + operator std::vector() const; + operator std::vector() const; + operator IfcUtil::IfcSchemaEntity() const; + operator SHARED_PTR() const; + operator IfcEntities() const; unsigned int Size() const; ArgumentPtr operator [] (unsigned int i) const; std::string toString() const; + bool isNull() const; }; // @@ -184,11 +157,16 @@ namespace IfcParse { operator bool() const; operator float() const; operator std::string() const; - operator EntityPtr() const; - operator EntitiesPtr() const; + operator std::vector() const; + operator std::vector() const; + operator std::vector() const; + operator IfcUtil::IfcSchemaEntity() const; + operator SHARED_PTR() const; + operator IfcEntities() const; unsigned int Size() const; ArgumentPtr operator [] (unsigned int i) const; std::string toString() const; + bool isNull() const; }; // @@ -198,18 +176,23 @@ namespace IfcParse { // class EntityArgument : public Argument { private: - EntityPtr entity; + IfcUtil::IfcSchemaEntity entity; public: - EntityArgument(EntityPtr e); + EntityArgument(IfcUtil::IfcSchemaEntity e); operator int() const; operator bool() const; operator float() const; operator std::string() const; - operator EntityPtr() const; - operator EntitiesPtr() const; + operator std::vector() const; + operator std::vector() const; + operator std::vector() const; + operator IfcUtil::IfcSchemaEntity() const; + operator SHARED_PTR() const; + operator IfcEntities() const; unsigned int Size() const; ArgumentPtr operator [] (unsigned int i) const; std::string toString() const; + bool isNull() const; }; // @@ -217,38 +200,24 @@ namespace IfcParse { // #1=IfcDirection((1.,0.,0.)); // ============================ // - class Entity { + class Entity : public IfcAbstractEntity { private: ArgumentPtr args; - void Load(std::vector& ids, bool seek); + Ifc2x3::Type::Enum _type; public: - unsigned int id; - unsigned int offset; - IfcSchema::Enum::IfcTypes type; - Entity(unsigned int i, Tokens* t, std::vector& ids, bool parse = false); + unsigned int _id; + unsigned int offset; + Entity(unsigned int i, Tokens* t); Entity(unsigned int i, Tokens* t, unsigned int o); - EntitiesPtr parents(IfcSchema::Enum::IfcTypes c = IfcSchema::Enum::ALL); - EntitiesPtr parents(IfcSchema::Enum::IfcTypes c, int i, const std::string& a); - ArgumentPtr operator[] (unsigned int i); + IfcEntities getInverse(Ifc2x3::Type::Enum c = Ifc2x3::Type::ALL); + IfcEntities getInverse(Ifc2x3::Type::Enum c, int i, const std::string& a); + void Load(std::vector& ids, bool seek=false); + ArgumentPtr getArgument (unsigned int i); std::string toString(); - std::string Datatype() const; - }; - - // - // A list of IFC entities - // - class Entities { - std::vector ls; - public: - typedef std::vector::const_iterator it; - void push(EntityPtr l); - void push(EntitiesPtr l); - it begin(); - it end(); - EntitiesPtr parents(IfcSchema::Enum::IfcTypes c = IfcSchema::Enum::ALL); - EntitiesPtr parents(IfcSchema::Enum::IfcTypes c, int i, const std::string& a); - EntityPtr operator[] (int i); - int Size() const; + std::string datatype(); + Ifc2x3::Type::Enum type(); + bool is(Ifc2x3::Type::Enum v); + unsigned int id(); }; class IfcException : public std::exception { @@ -261,9 +230,9 @@ namespace IfcParse { }; } -typedef IfcParse::EntityPtr IfcEntity; -typedef IfcParse::EntitiesPtr IfcEntities; -typedef std::map MapEntitiesByType; +typedef IfcUtil::IfcSchemaEntity IfcEntity; +typedef IfcEntities IfcEntities; +typedef std::map MapEntitiesByType; typedef std::map MapEntityById; typedef std::map MapEntitiesByRef; typedef std::map MapOffsetById; @@ -278,10 +247,22 @@ private: static MapEntitiesByRef byref; static MapOffsetById offsets; static unsigned int lastId; + static std::ostream* log; public: + static void SetOutput(std::ostream* l); + static void LogMessage(const std::string& type, const std::string& message, const SHARED_PTR& entity=SHARED_PTR()); static IfcParse::File* file; static IfcParse::Tokens* tokens; - static IfcEntities EntitiesByType(IfcSchema::Enum::IfcTypes t); + template + static typename T::list EntitiesByType() { + IfcEntities e = EntitiesByType(T::Class()); + typename T::list l ( new IfcTemplatedEntityList() ); \ + for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) { \ + l->push(reinterpret_pointer_cast(*it));\ + } + return l; + } + static IfcEntities EntitiesByType(Ifc2x3::Type::Enum t); static IfcEntities EntitiesByReference(int id); static IfcEntity EntityById(int id); static bool Init(const std::string& fn); @@ -291,6 +272,6 @@ public: static int CircleSegments; }; -float UnitPrefixToValue(const std::string& s); +float UnitPrefixToValue( Ifc2x3::IfcSIPrefix::IfcSIPrefix v ); #endif diff --git a/src/ifcparse/IfcRegister.cpp b/src/ifcparse/IfcRegister.cpp new file mode 100644 index 0000000000..ace2835a46 --- /dev/null +++ b/src/ifcparse/IfcRegister.cpp @@ -0,0 +1,56 @@ +/******************************************************************************** +* * +* This file is part of IfcOpenShell. * +* * +* IfcOpenShell is free software: you can redistribute it and/or modify * +* it under the terms of the Lesser GNU General Public License as published by * +* the Free Software Foundation, either version 3.0 of the License, or * +* (at your option) any later version. * +* * +* IfcOpenShell is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* Lesser GNU General Public License for more details. * +* * +* You should have received a copy of the Lesser GNU General Public License * +* along with this program. If not, see . * +* * +********************************************************************************/ + +#include "IfcGeom.h" + +namespace IfcGeom { + namespace Cache { + std::map Shape; + void PurgeShapeCache() { + Shape.clear(); + } + } +} + +using namespace Ifc2x3; +using namespace IfcUtil; + +bool IfcGeom::convert_shape(const SHARED_PTR& l, TopoDS_Shape& r) { + const unsigned int id = l->entity->id(); + std::map::const_iterator it = Cache::Shape.find(id); + if ( it != Cache::Shape.end() ) { r = it->second; return true; } +#include "IfcRegisterConvertShape.h" + Ifc::LogMessage("Error","No operation defined for:",l->entity); + return false; +} +bool IfcGeom::convert_wire(const SHARED_PTR& l, TopoDS_Wire& r) { +#include "IfcRegisterConvertWire.h" + Ifc::LogMessage("Error","No operation defined for:",l->entity); + return false; +} +bool IfcGeom::convert_face(const SHARED_PTR& l, TopoDS_Face& r) { +#include "IfcRegisterConvertFace.h" + Ifc::LogMessage("Error","No operation defined for:",l->entity); + return false; +} +bool IfcGeom::convert_curve(const SHARED_PTR& l, Handle(Geom_Curve)& r) { +#include "IfcRegisterConvertCurve.h" + Ifc::LogMessage("Error","No operation defined for:",l->entity); + return false; +} \ No newline at end of file diff --git a/src/ifcparse/IfcRegister.h b/src/ifcparse/IfcRegister.h new file mode 100644 index 0000000000..58703f7e7c --- /dev/null +++ b/src/ifcparse/IfcRegister.h @@ -0,0 +1,80 @@ +/******************************************************************************** +* * +* This file is part of IfcOpenShell. * +* * +* IfcOpenShell is free software: you can redistribute it and/or modify * +* it under the terms of the Lesser GNU General Public License as published by * +* the Free Software Foundation, either version 3.0 of the License, or * +* (at your option) any later version. * +* * +* IfcOpenShell is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* Lesser GNU General Public License for more details. * +* * +* You should have received a copy of the Lesser GNU General Public License * +* along with this program. If not, see . * +* * +********************************************************************************/ + +/******************************************************************************** + * * + * This file registers function prototypes for all supported IFC geometrical * + * entities. For entities of type CLASS an std::map is also created to cache * + * the output of the conversion functions * + * * + ********************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../ifcparse/IfcParse.h" + +using namespace Ifc2x3; + +SHAPE(IfcExtrudedAreaSolid); +SHAPE(IfcClosedShell); +SHAPE(IfcConnectedFaceSet); +SHAPE(IfcFacetedBrep); +SHAPE(IfcShellBasedSurfaceModel); +SHAPE(IfcFaceBasedSurfaceModel); +SHAPE(IfcBooleanClippingResult); +SHAPE(IfcShapeRepresentation); +SHAPE(IfcMappedItem); +SHAPE(IfcPolygonalBoundedHalfSpace); +SHAPE(IfcHalfSpaceSolid); + +FACE(IfcArbitraryClosedProfileDef); +FACE(IfcArbitraryProfileDefWithVoids); +FACE(IfcRectangleProfileDef); +FACE(IfcIShapeProfileDef); +FACE(IfcCShapeProfileDef); +FACE(IfcLShapeProfileDef); +FACE(IfcCircleProfileDef); +FACE(IfcFace); +FACE(IfcCircleHollowProfileDef); + +WIRE(IfcPolyline); +WIRE(IfcPolyLoop); +WIRE(IfcCompositeCurve); +WIRE(IfcTrimmedCurve); + +CURVE(IfcCircle); +CURVE(IfcEllipse); +CURVE(IfcLine); + +CLASS(IfcCartesianPoint,gp_Pnt); +CLASS(IfcDirection,gp_Dir); +CLASS(IfcAxis2Placement2D,gp_Trsf2d); +CLASS(IfcAxis2Placement3D,gp_Trsf); +CLASS(IfcCartesianTransformationOperator2D,gp_Trsf2d); +CLASS(IfcCartesianTransformationOperator3D,gp_Trsf); +CLASS(IfcObjectPlacement,gp_Trsf); +CLASS(IfcVector,gp_Vec); +CLASS(IfcPlane,gp_Pln); \ No newline at end of file diff --git a/src/ifcparse/IfcRegisterConvertCurve.h b/src/ifcparse/IfcRegisterConvertCurve.h new file mode 100644 index 0000000000..1cb61ed0fe --- /dev/null +++ b/src/ifcparse/IfcRegisterConvertCurve.h @@ -0,0 +1,6 @@ +#include "IfcRegisterUndef.h" +#define CURVE(T) \ + if ( l->is(T::Class()) ) return convert(reinterpret_pointer_cast(l),r); +#include "IfcRegisterDef.h" + +#include "IfcRegister.h" \ No newline at end of file diff --git a/src/ifcparse/IfcRegisterConvertFace.h b/src/ifcparse/IfcRegisterConvertFace.h new file mode 100644 index 0000000000..9c6e8d9514 --- /dev/null +++ b/src/ifcparse/IfcRegisterConvertFace.h @@ -0,0 +1,6 @@ +#include "IfcRegisterUndef.h" +#define FACE(T) \ + if ( l->is(T::Class()) ) return convert(reinterpret_pointer_cast(l),r); +#include "IfcRegisterDef.h" + +#include "IfcRegister.h" \ No newline at end of file diff --git a/src/ifcparse/IfcRegisterConvertShape.h b/src/ifcparse/IfcRegisterConvertShape.h new file mode 100644 index 0000000000..0bcd61842d --- /dev/null +++ b/src/ifcparse/IfcRegisterConvertShape.h @@ -0,0 +1,14 @@ +#include "IfcRegisterUndef.h" +#define SHAPE(T) \ + if ( l->is(T::Class()) ) { \ + try { \ + bool b = convert(reinterpret_pointer_cast(l),r); \ + if ( b ) { \ + Cache::Shape[l->entity->id()] = r; \ + return true; \ + } else { return false; }\ + } catch(...) { Ifc::LogMessage("Error","Failed to convert:",l->entity); } \ + } +#include "IfcRegisterDef.h" + +#include "IfcRegister.h" \ No newline at end of file diff --git a/src/ifcparse/IfcRegisterConvertWire.h b/src/ifcparse/IfcRegisterConvertWire.h new file mode 100644 index 0000000000..54700ac0e8 --- /dev/null +++ b/src/ifcparse/IfcRegisterConvertWire.h @@ -0,0 +1,6 @@ +#include "IfcRegisterUndef.h" +#define WIRE(T) \ + if ( l->is(T::Class()) ) return convert(reinterpret_pointer_cast(l),r); +#include "IfcRegisterDef.h" + +#include "IfcRegister.h" \ No newline at end of file diff --git a/src/ifcparse/IfcRegisterCreateCache.h b/src/ifcparse/IfcRegisterCreateCache.h new file mode 100644 index 0000000000..62eb83b0b8 --- /dev/null +++ b/src/ifcparse/IfcRegisterCreateCache.h @@ -0,0 +1,6 @@ +#include "IfcRegisterUndef.h" +#define CLASS(T,V) \ + std::map T; +#include "IfcRegisterDef.h" + +#include "IfcRegister.h" \ No newline at end of file diff --git a/src/ifcparse/IfcRegisterDef.h b/src/ifcparse/IfcRegisterDef.h new file mode 100644 index 0000000000..d1d9f1c000 --- /dev/null +++ b/src/ifcparse/IfcRegisterDef.h @@ -0,0 +1,15 @@ +#ifndef SHAPE +#define SHAPE(T) +#endif +#ifndef WIRE +#define WIRE(T) +#endif +#ifndef FACE +#define FACE(T) +#endif +#ifndef CURVE +#define CURVE(T) +#endif +#ifndef CLASS +#define CLASS(T,V) +#endif \ No newline at end of file diff --git a/src/ifcparse/IfcRegisterGeomHeader.h b/src/ifcparse/IfcRegisterGeomHeader.h new file mode 100644 index 0000000000..6cf3d0b467 --- /dev/null +++ b/src/ifcparse/IfcRegisterGeomHeader.h @@ -0,0 +1,9 @@ +#include "IfcRegisterUndef.h" +#define CLASS(T,V) bool convert(const T::ptr& L, V& r); +#define SHAPE(T) CLASS(T,TopoDS_Shape) +#define WIRE(T) CLASS(T,TopoDS_Wire) +#define FACE(T) CLASS(T,TopoDS_Face) +#define CURVE(T) CLASS(T,Handle(Geom_Curve)) +#include "IfcRegisterDef.h" + +#include "IfcRegister.h" \ No newline at end of file diff --git a/src/ifcparse/IfcRegisterPurgeCache.h b/src/ifcparse/IfcRegisterPurgeCache.h new file mode 100644 index 0000000000..ec237a168d --- /dev/null +++ b/src/ifcparse/IfcRegisterPurgeCache.h @@ -0,0 +1,6 @@ +#include "IfcRegisterUndef.h" +#define CLASS(T,V) \ + T.clear(); +#include "IfcRegisterDef.h" + +#include "IfcRegister.h" \ No newline at end of file diff --git a/src/ifcparse/IfcRegisterUndef.h b/src/ifcparse/IfcRegisterUndef.h new file mode 100644 index 0000000000..d39fa4ab15 --- /dev/null +++ b/src/ifcparse/IfcRegisterUndef.h @@ -0,0 +1,15 @@ +#ifdef SHAPE +#undef SHAPE +#endif +#ifdef WIRE +#undef WIRE +#endif +#ifdef FACE +#undef FACE +#endif +#ifdef CURVE +#undef CURVE +#endif +#ifdef CLASS +#undef CLASS +#endif \ No newline at end of file diff --git a/src/ifcparse/IfcUtil.cpp b/src/ifcparse/IfcUtil.cpp new file mode 100644 index 0000000000..82f67d3697 --- /dev/null +++ b/src/ifcparse/IfcUtil.cpp @@ -0,0 +1,61 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +#include "IfcUtil.h" + +void IfcEntityList::push(IfcUtil::IfcSchemaEntity l) { + if ( l ) ls.push_back(l); +} +void IfcEntityList::push(IfcEntities l) { + for( it i = l->begin(); i != l->end(); ++i ) { + if ( *i ) ls.push_back(*i); + } +} +int IfcEntityList::Size() const { return (unsigned int) ls.size(); } +IfcEntityList::it IfcEntityList::begin() { return ls.begin(); } +IfcEntityList::it IfcEntityList::end() { return ls.end(); } +IfcUtil::IfcSchemaEntity IfcEntityList::operator[] (int i) { + return ls[i]; +} +IfcEntities IfcEntityList::getInverse(Ifc2x3::Type::Enum c) { + IfcEntities l = IfcEntities(new IfcEntityList()); + for( it i = begin(); i != end(); ++i ) { + l->push((*i)->entity->getInverse(c)); + } + return l; +} +IfcEntities IfcEntityList::getInverse(Ifc2x3::Type::Enum c, int ar, const std::string& a) { + IfcEntities l = IfcEntities(new IfcEntityList()); + for( it i = begin(); i != end(); ++i ) { + l->push((*i)->entity->getInverse(c,ar,a)); + } + return l; +} + +bool IfcUtil::IfcEntitySelect::is(Ifc2x3::Type::Enum v) { return entity->is(v); } +Ifc2x3::Type::Enum IfcUtil::IfcEntitySelect::type() { return entity->type(); } +IfcUtil::IfcEntitySelect::IfcEntitySelect(SHARED_PTR b) { entity = b->entity; } +IfcUtil::IfcEntitySelect::IfcEntitySelect(IfcAbstractEntityPtr e) { entity = e; } +bool IfcUtil::IfcEntitySelect::isSimpleType() { return false; } + +bool IfcUtil::IfcArgumentSelect::is(Ifc2x3::Type::Enum v) { return _type == v; } +Ifc2x3::Type::Enum IfcUtil::IfcArgumentSelect::type() { return _type; } +IfcUtil::IfcArgumentSelect::IfcArgumentSelect(Ifc2x3::Type::Enum t, ArgumentPtr a) { _type = t; arg = a; } +ArgumentPtr IfcUtil::IfcArgumentSelect::wrappedValue() { return arg; } +bool IfcUtil::IfcArgumentSelect::isSimpleType() { return true; } \ No newline at end of file diff --git a/src/ifcparse/IfcUtil.h b/src/ifcparse/IfcUtil.h new file mode 100644 index 0000000000..1bfe342f49 --- /dev/null +++ b/src/ifcparse/IfcUtil.h @@ -0,0 +1,145 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +#ifndef IFCUTIL_H +#define IFCUTIL_H + +#include +#include + +#include "../ifcparse/SharedPointer.h" +#include "../ifcparse/Ifc2x3enum.h" + +class IfcAbstractEntity; +typedef SHARED_PTR IfcAbstractEntityPtr; + +class IfcEntityList; +typedef SHARED_PTR IfcEntities; + +template +inline SHARED_PTR reinterpret_pointer_cast(SHARED_PTR from) { + SHARED_PTR v = std::tr1::static_pointer_cast(from); + return std::tr1::static_pointer_cast(v); +} + +namespace IfcUtil { + +class IfcBaseClass { +public: + IfcAbstractEntityPtr entity; + virtual bool is(Ifc2x3::Type::Enum v) = 0; + virtual Ifc2x3::Type::Enum type() = 0; +}; + +typedef SHARED_PTR IfcSchemaEntity; + +} + +class IfcEntityList { + std::vector ls; +public: + typedef std::vector::const_iterator it; + IfcEntities getInverse(Ifc2x3::Type::Enum c = Ifc2x3::Type::ALL); + IfcEntities getInverse(Ifc2x3::Type::Enum c, int i, const std::string& a); + void push(IfcUtil::IfcSchemaEntity l); + void push(IfcEntities l); + it begin(); + it end(); + IfcUtil::IfcSchemaEntity operator[] (int i); + int Size() const; +}; + +template +class IfcTemplatedEntityList { + std::vector > ls; +public: + typedef typename std::vector >::const_iterator it; + inline void push(SHARED_PTR t) {if (t) ls.push_back(t);} + inline void push(SHARED_PTR< IfcTemplatedEntityList > t) { for ( typename T::it it = t->begin(); it != t->end(); ++it ) push(*it); } + inline it begin() { return ls.begin(); } + inline it end() { return ls.end(); } + inline T operator[] (int i) { return ls[i]; } + inline unsigned int Size() const { return (unsigned int) ls.size(); } +}; + +class Argument; +typedef SHARED_PTR ArgumentPtr; + +namespace IfcUtil { + class IfcAbstractSelect : public IfcBaseClass { + public: + typedef SHARED_PTR< IfcTemplatedEntityList > list; + typedef IfcTemplatedEntityList::it it; + typedef SHARED_PTR ptr; + virtual bool isSimpleType() = 0; + }; + class IfcEntitySelect : public IfcAbstractSelect { + public: + typedef SHARED_PTR ptr; + IfcEntitySelect(SHARED_PTR b); + IfcEntitySelect(IfcAbstractEntityPtr e); + bool is(Ifc2x3::Type::Enum v); + Ifc2x3::Type::Enum type(); + bool isSimpleType(); + }; + class IfcArgumentSelect : public IfcAbstractSelect { + Ifc2x3::Type::Enum _type; + ArgumentPtr arg; + public: + typedef SHARED_PTR ptr; + IfcArgumentSelect(Ifc2x3::Type::Enum t, ArgumentPtr a); + ArgumentPtr wrappedValue(); + bool is(Ifc2x3::Type::Enum v); + Ifc2x3::Type::Enum type(); + bool isSimpleType(); + }; +} + +class Argument { +protected: +public: + virtual operator int() const = 0; + virtual operator bool() const = 0; + virtual operator float() const = 0; + virtual operator std::string() const = 0; + virtual operator std::vector() const = 0; + virtual operator std::vector() const = 0; + virtual operator std::vector() const = 0; + virtual operator IfcUtil::IfcSchemaEntity() const = 0; + virtual operator SHARED_PTR() const = 0; + virtual operator IfcEntities() const = 0; + virtual unsigned int Size() const = 0; + virtual ArgumentPtr operator [] (unsigned int i) const = 0; + virtual std::string toString() const = 0; + virtual bool isNull() const = 0; +}; + +class IfcAbstractEntity { +public: + virtual IfcEntities getInverse(Ifc2x3::Type::Enum c = Ifc2x3::Type::ALL) = 0; + virtual IfcEntities getInverse(Ifc2x3::Type::Enum c, int i, const std::string& a) = 0; + virtual std::string datatype() = 0; + virtual ArgumentPtr getArgument (unsigned int i) = 0; + virtual Ifc2x3::Type::Enum type() = 0; + virtual bool is(Ifc2x3::Type::Enum v) = 0; + virtual std::string toString() = 0; + virtual unsigned int id() = 0; +}; + +#endif \ No newline at end of file diff --git a/src/ifcparse/SharedPointer.h b/src/ifcparse/SharedPointer.h new file mode 100644 index 0000000000..6de865ec09 --- /dev/null +++ b/src/ifcparse/SharedPointer.h @@ -0,0 +1,38 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +/******************************************************************************** + * * + * This file defines the shared pointer implementation to use, shared pointers * + * are used extensively in IfcOpenShell * + * * + ********************************************************************************/ + +#ifdef __GNUC__ +#include +#define SHARED_PTR std::tr1::shared_ptr +#else +#ifdef _MSC_VER +#include +#define SHARED_PTR std::tr1::shared_ptr +#else +#include +#define SHARED_PTR boost::shared_ptr +#endif +#endif \ No newline at end of file