/********************************************************************************

* *

* 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 <http://www.gnu.org/licenses/>. *

* *

********************************************************************************/

/********************************************************************************

* *

* This file has been generated from IFC4.exp. Do not make modifications *

* but instead modify the python script that has been used to generate this. *

* *

********************************************************************************/

#ifdef USE_IFC4

#include <set>

#include "../ifcparse/Ifc4.h"

#include "../ifcparse/Ifc4-rt.h"

#include "../ifcparse/IfcException.h"

#include "../ifcparse/IfcWrite.h"

#include "../ifcparse/IfcWritableEntity.h"

#include "../ifcparse/IfcUtil.h"

#include "../ifcparse/IfcEntityDescriptor.h"

using namespace Ifc4;

using namespace IfcParse;

using namespace IfcWrite;

using namespace IfcUtil;

std::map<Type::Enum,IfcEntityDescriptor*> entity_descriptor_map;

std::map<Type::Enum,IfcEnumerationDescriptor*> enumeration_descriptor_map;

std::map<std::pair<Type::Enum, std::string>, std::pair<Type::Enum, int> > inverse_map;

std::map<Type::Enum,std::set<int> > derived_map;

void InitDescriptorMap() {

IfcEntityDescriptor* current;

current = entity_descriptor_map[Type::IfcAbsorbedDoseMeasure] = new IfcEntityDescriptor(Type::IfcAbsorbedDoseMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcAccelerationMeasure] = new IfcEntityDescriptor(Type::IfcAccelerationMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcAmountOfSubstanceMeasure] = new IfcEntityDescriptor(Type::IfcAmountOfSubstanceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcAngularVelocityMeasure] = new IfcEntityDescriptor(Type::IfcAngularVelocityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcAreaDensityMeasure] = new IfcEntityDescriptor(Type::IfcAreaDensityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcAreaMeasure] = new IfcEntityDescriptor(Type::IfcAreaMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcBoolean] = new IfcEntityDescriptor(Type::IfcBoolean,0);

current->add("wrappedValue",false,IfcUtil::Argument_BOOL);

current = entity_descriptor_map[Type::IfcBoxAlignment] = new IfcEntityDescriptor(Type::IfcBoxAlignment,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcCardinalPointReference] = new IfcEntityDescriptor(Type::IfcCardinalPointReference,0);

current->add("wrappedValue",false,IfcUtil::Argument_INT);

current = entity_descriptor_map[Type::IfcComplexNumber] = new IfcEntityDescriptor(Type::IfcComplexNumber,0);

current->add("wrappedValue",false,IfcUtil::Argument_VECTOR_DOUBLE);

current = entity_descriptor_map[Type::IfcCompoundPlaneAngleMeasure] = new IfcEntityDescriptor(Type::IfcCompoundPlaneAngleMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_VECTOR_INT);

current = entity_descriptor_map[Type::IfcContextDependentMeasure] = new IfcEntityDescriptor(Type::IfcContextDependentMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcCountMeasure] = new IfcEntityDescriptor(Type::IfcCountMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcCurvatureMeasure] = new IfcEntityDescriptor(Type::IfcCurvatureMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcDate] = new IfcEntityDescriptor(Type::IfcDate,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcDateTime] = new IfcEntityDescriptor(Type::IfcDateTime,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcDayInMonthNumber] = new IfcEntityDescriptor(Type::IfcDayInMonthNumber,0);

current->add("wrappedValue",false,IfcUtil::Argument_INT);

current = entity_descriptor_map[Type::IfcDayInWeekNumber] = new IfcEntityDescriptor(Type::IfcDayInWeekNumber,0);

current->add("wrappedValue",false,IfcUtil::Argument_INT);

current = entity_descriptor_map[Type::IfcDescriptiveMeasure] = new IfcEntityDescriptor(Type::IfcDescriptiveMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcDimensionCount] = new IfcEntityDescriptor(Type::IfcDimensionCount,0);

current->add("wrappedValue",false,IfcUtil::Argument_INT);

current = entity_descriptor_map[Type::IfcDoseEquivalentMeasure] = new IfcEntityDescriptor(Type::IfcDoseEquivalentMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcDuration] = new IfcEntityDescriptor(Type::IfcDuration,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcDynamicViscosityMeasure] = new IfcEntityDescriptor(Type::IfcDynamicViscosityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcElectricCapacitanceMeasure] = new IfcEntityDescriptor(Type::IfcElectricCapacitanceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcElectricChargeMeasure] = new IfcEntityDescriptor(Type::IfcElectricChargeMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcElectricConductanceMeasure] = new IfcEntityDescriptor(Type::IfcElectricConductanceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcElectricCurrentMeasure] = new IfcEntityDescriptor(Type::IfcElectricCurrentMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcElectricResistanceMeasure] = new IfcEntityDescriptor(Type::IfcElectricResistanceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcElectricVoltageMeasure] = new IfcEntityDescriptor(Type::IfcElectricVoltageMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcEnergyMeasure] = new IfcEntityDescriptor(Type::IfcEnergyMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcFontStyle] = new IfcEntityDescriptor(Type::IfcFontStyle,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcFontVariant] = new IfcEntityDescriptor(Type::IfcFontVariant,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcFontWeight] = new IfcEntityDescriptor(Type::IfcFontWeight,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcForceMeasure] = new IfcEntityDescriptor(Type::IfcForceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcFrequencyMeasure] = new IfcEntityDescriptor(Type::IfcFrequencyMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcGloballyUniqueId] = new IfcEntityDescriptor(Type::IfcGloballyUniqueId,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcHeatFluxDensityMeasure] = new IfcEntityDescriptor(Type::IfcHeatFluxDensityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcHeatingValueMeasure] = new IfcEntityDescriptor(Type::IfcHeatingValueMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcIdentifier] = new IfcEntityDescriptor(Type::IfcIdentifier,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcIlluminanceMeasure] = new IfcEntityDescriptor(Type::IfcIlluminanceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcInductanceMeasure] = new IfcEntityDescriptor(Type::IfcInductanceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcInteger] = new IfcEntityDescriptor(Type::IfcInteger,0);

current->add("wrappedValue",false,IfcUtil::Argument_INT);

current = entity_descriptor_map[Type::IfcIntegerCountRateMeasure] = new IfcEntityDescriptor(Type::IfcIntegerCountRateMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_INT);

current = entity_descriptor_map[Type::IfcIonConcentrationMeasure] = new IfcEntityDescriptor(Type::IfcIonConcentrationMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcIsothermalMoistureCapacityMeasure] = new IfcEntityDescriptor(Type::IfcIsothermalMoistureCapacityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcKinematicViscosityMeasure] = new IfcEntityDescriptor(Type::IfcKinematicViscosityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcLabel] = new IfcEntityDescriptor(Type::IfcLabel,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcLanguageId] = new IfcEntityDescriptor(Type::IfcLanguageId,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcLengthMeasure] = new IfcEntityDescriptor(Type::IfcLengthMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcLinearForceMeasure] = new IfcEntityDescriptor(Type::IfcLinearForceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcLinearMomentMeasure] = new IfcEntityDescriptor(Type::IfcLinearMomentMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcLinearStiffnessMeasure] = new IfcEntityDescriptor(Type::IfcLinearStiffnessMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcLinearVelocityMeasure] = new IfcEntityDescriptor(Type::IfcLinearVelocityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcLogical] = new IfcEntityDescriptor(Type::IfcLogical,0);

current->add("wrappedValue",false,IfcUtil::Argument_BOOL);

current = entity_descriptor_map[Type::IfcLuminousFluxMeasure] = new IfcEntityDescriptor(Type::IfcLuminousFluxMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcLuminousIntensityDistributionMeasure] = new IfcEntityDescriptor(Type::IfcLuminousIntensityDistributionMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcLuminousIntensityMeasure] = new IfcEntityDescriptor(Type::IfcLuminousIntensityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMagneticFluxDensityMeasure] = new IfcEntityDescriptor(Type::IfcMagneticFluxDensityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMagneticFluxMeasure] = new IfcEntityDescriptor(Type::IfcMagneticFluxMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMassDensityMeasure] = new IfcEntityDescriptor(Type::IfcMassDensityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMassFlowRateMeasure] = new IfcEntityDescriptor(Type::IfcMassFlowRateMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMassMeasure] = new IfcEntityDescriptor(Type::IfcMassMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMassPerLengthMeasure] = new IfcEntityDescriptor(Type::IfcMassPerLengthMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcModulusOfElasticityMeasure] = new IfcEntityDescriptor(Type::IfcModulusOfElasticityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcModulusOfLinearSubgradeReactionMeasure] = new IfcEntityDescriptor(Type::IfcModulusOfLinearSubgradeReactionMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcModulusOfRotationalSubgradeReactionMeasure] = new IfcEntityDescriptor(Type::IfcModulusOfRotationalSubgradeReactionMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcModulusOfSubgradeReactionMeasure] = new IfcEntityDescriptor(Type::IfcModulusOfSubgradeReactionMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMoistureDiffusivityMeasure] = new IfcEntityDescriptor(Type::IfcMoistureDiffusivityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMolecularWeightMeasure] = new IfcEntityDescriptor(Type::IfcMolecularWeightMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMomentOfInertiaMeasure] = new IfcEntityDescriptor(Type::IfcMomentOfInertiaMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMonetaryMeasure] = new IfcEntityDescriptor(Type::IfcMonetaryMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMonthInYearNumber] = new IfcEntityDescriptor(Type::IfcMonthInYearNumber,0);

current->add("wrappedValue",false,IfcUtil::Argument_INT);

current = entity_descriptor_map[Type::IfcNonNegativeLengthMeasure] = new IfcEntityDescriptor(Type::IfcNonNegativeLengthMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcNormalisedRatioMeasure] = new IfcEntityDescriptor(Type::IfcNormalisedRatioMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcNumericMeasure] = new IfcEntityDescriptor(Type::IfcNumericMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcPHMeasure] = new IfcEntityDescriptor(Type::IfcPHMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcParameterValue] = new IfcEntityDescriptor(Type::IfcParameterValue,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcPlanarForceMeasure] = new IfcEntityDescriptor(Type::IfcPlanarForceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcPlaneAngleMeasure] = new IfcEntityDescriptor(Type::IfcPlaneAngleMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcPositiveLengthMeasure] = new IfcEntityDescriptor(Type::IfcPositiveLengthMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcPositivePlaneAngleMeasure] = new IfcEntityDescriptor(Type::IfcPositivePlaneAngleMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcPositiveRatioMeasure] = new IfcEntityDescriptor(Type::IfcPositiveRatioMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcPowerMeasure] = new IfcEntityDescriptor(Type::IfcPowerMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcPresentableText] = new IfcEntityDescriptor(Type::IfcPresentableText,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcPressureMeasure] = new IfcEntityDescriptor(Type::IfcPressureMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcPropertySetDefinitionSet] = new IfcEntityDescriptor(Type::IfcPropertySetDefinitionSet,0);

current->add("wrappedValue",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcRadioActivityMeasure] = new IfcEntityDescriptor(Type::IfcRadioActivityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcRatioMeasure] = new IfcEntityDescriptor(Type::IfcRatioMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcReal] = new IfcEntityDescriptor(Type::IfcReal,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcRotationalFrequencyMeasure] = new IfcEntityDescriptor(Type::IfcRotationalFrequencyMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcRotationalMassMeasure] = new IfcEntityDescriptor(Type::IfcRotationalMassMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcRotationalStiffnessMeasure] = new IfcEntityDescriptor(Type::IfcRotationalStiffnessMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSectionModulusMeasure] = new IfcEntityDescriptor(Type::IfcSectionModulusMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSectionalAreaIntegralMeasure] = new IfcEntityDescriptor(Type::IfcSectionalAreaIntegralMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcShearModulusMeasure] = new IfcEntityDescriptor(Type::IfcShearModulusMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSolidAngleMeasure] = new IfcEntityDescriptor(Type::IfcSolidAngleMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSoundPowerLevelMeasure] = new IfcEntityDescriptor(Type::IfcSoundPowerLevelMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSoundPowerMeasure] = new IfcEntityDescriptor(Type::IfcSoundPowerMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSoundPressureLevelMeasure] = new IfcEntityDescriptor(Type::IfcSoundPressureLevelMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSoundPressureMeasure] = new IfcEntityDescriptor(Type::IfcSoundPressureMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSpecificHeatCapacityMeasure] = new IfcEntityDescriptor(Type::IfcSpecificHeatCapacityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSpecularExponent] = new IfcEntityDescriptor(Type::IfcSpecularExponent,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSpecularRoughness] = new IfcEntityDescriptor(Type::IfcSpecularRoughness,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcTemperatureGradientMeasure] = new IfcEntityDescriptor(Type::IfcTemperatureGradientMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcTemperatureRateOfChangeMeasure] = new IfcEntityDescriptor(Type::IfcTemperatureRateOfChangeMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcText] = new IfcEntityDescriptor(Type::IfcText,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcTextAlignment] = new IfcEntityDescriptor(Type::IfcTextAlignment,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcTextDecoration] = new IfcEntityDescriptor(Type::IfcTextDecoration,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcTextFontName] = new IfcEntityDescriptor(Type::IfcTextFontName,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcTextTransformation] = new IfcEntityDescriptor(Type::IfcTextTransformation,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcThermalAdmittanceMeasure] = new IfcEntityDescriptor(Type::IfcThermalAdmittanceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcThermalConductivityMeasure] = new IfcEntityDescriptor(Type::IfcThermalConductivityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcThermalExpansionCoefficientMeasure] = new IfcEntityDescriptor(Type::IfcThermalExpansionCoefficientMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcThermalResistanceMeasure] = new IfcEntityDescriptor(Type::IfcThermalResistanceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcThermalTransmittanceMeasure] = new IfcEntityDescriptor(Type::IfcThermalTransmittanceMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcThermodynamicTemperatureMeasure] = new IfcEntityDescriptor(Type::IfcThermodynamicTemperatureMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcTime] = new IfcEntityDescriptor(Type::IfcTime,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcTimeMeasure] = new IfcEntityDescriptor(Type::IfcTimeMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcTimeStamp] = new IfcEntityDescriptor(Type::IfcTimeStamp,0);

current->add("wrappedValue",false,IfcUtil::Argument_INT);

current = entity_descriptor_map[Type::IfcTorqueMeasure] = new IfcEntityDescriptor(Type::IfcTorqueMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcURIReference] = new IfcEntityDescriptor(Type::IfcURIReference,0);

current->add("wrappedValue",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcVaporPermeabilityMeasure] = new IfcEntityDescriptor(Type::IfcVaporPermeabilityMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcVolumeMeasure] = new IfcEntityDescriptor(Type::IfcVolumeMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcVolumetricFlowRateMeasure] = new IfcEntityDescriptor(Type::IfcVolumetricFlowRateMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcWarpingConstantMeasure] = new IfcEntityDescriptor(Type::IfcWarpingConstantMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcWarpingMomentMeasure] = new IfcEntityDescriptor(Type::IfcWarpingMomentMeasure,0);

current->add("wrappedValue",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcActorRole] = new IfcEntityDescriptor(Type::IfcActorRole,0);

current->add("Role",false,IfcUtil::Argument_ENUMERATION,Type::IfcRoleEnum);

current->add("UserDefinedRole",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcAddress] = new IfcEntityDescriptor(Type::IfcAddress,0);

current->add("Purpose",true,IfcUtil::Argument_ENUMERATION,Type::IfcAddressTypeEnum);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("UserDefinedPurpose",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcApplication] = new IfcEntityDescriptor(Type::IfcApplication,0);

current->add("ApplicationDeveloper",false,IfcUtil::Argument_ENTITY);

current->add("Version",false,IfcUtil::Argument_STRING);

current->add("ApplicationFullName",false,IfcUtil::Argument_STRING);

current->add("ApplicationIdentifier",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcAppliedValue] = new IfcEntityDescriptor(Type::IfcAppliedValue,0);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("AppliedValue",true,IfcUtil::Argument_ENTITY);

current->add("UnitBasis",true,IfcUtil::Argument_ENTITY);

current->add("ApplicableDate",true,IfcUtil::Argument_STRING);

current->add("FixedUntilDate",true,IfcUtil::Argument_STRING);

current->add("Category",true,IfcUtil::Argument_STRING);

current->add("Condition",true,IfcUtil::Argument_STRING);

current->add("ArithmeticOperator",true,IfcUtil::Argument_ENUMERATION,Type::IfcArithmeticOperatorEnum);

current->add("Components",true,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcApproval] = new IfcEntityDescriptor(Type::IfcApproval,0);

current->add("Identifier",true,IfcUtil::Argument_STRING);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("TimeOfApproval",true,IfcUtil::Argument_STRING);

current->add("Status",true,IfcUtil::Argument_STRING);

current->add("Level",true,IfcUtil::Argument_STRING);

current->add("Qualifier",true,IfcUtil::Argument_STRING);

current->add("RequestingApproval",true,IfcUtil::Argument_ENTITY);

current->add("GivingApproval",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcBoundaryCondition] = new IfcEntityDescriptor(Type::IfcBoundaryCondition,0);

current->add("Name",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcBoundaryEdgeCondition] = new IfcEntityDescriptor(Type::IfcBoundaryEdgeCondition,entity_descriptor_map.find(Type::IfcBoundaryCondition)->second);

current->add("TranslationalStiffnessByLengthX",true,IfcUtil::Argument_ENTITY);

current->add("TranslationalStiffnessByLengthY",true,IfcUtil::Argument_ENTITY);

current->add("TranslationalStiffnessByLengthZ",true,IfcUtil::Argument_ENTITY);

current->add("RotationalStiffnessByLengthX",true,IfcUtil::Argument_ENTITY);

current->add("RotationalStiffnessByLengthY",true,IfcUtil::Argument_ENTITY);

current->add("RotationalStiffnessByLengthZ",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcBoundaryFaceCondition] = new IfcEntityDescriptor(Type::IfcBoundaryFaceCondition,entity_descriptor_map.find(Type::IfcBoundaryCondition)->second);

current->add("TranslationalStiffnessByAreaX",true,IfcUtil::Argument_ENTITY);

current->add("TranslationalStiffnessByAreaY",true,IfcUtil::Argument_ENTITY);

current->add("TranslationalStiffnessByAreaZ",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcBoundaryNodeCondition] = new IfcEntityDescriptor(Type::IfcBoundaryNodeCondition,entity_descriptor_map.find(Type::IfcBoundaryCondition)->second);

current->add("TranslationalStiffnessX",true,IfcUtil::Argument_ENTITY);

current->add("TranslationalStiffnessY",true,IfcUtil::Argument_ENTITY);

current->add("TranslationalStiffnessZ",true,IfcUtil::Argument_ENTITY);

current->add("RotationalStiffnessX",true,IfcUtil::Argument_ENTITY);

current->add("RotationalStiffnessY",true,IfcUtil::Argument_ENTITY);

current->add("RotationalStiffnessZ",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcBoundaryNodeConditionWarping] = new IfcEntityDescriptor(Type::IfcBoundaryNodeConditionWarping,entity_descriptor_map.find(Type::IfcBoundaryNodeCondition)->second);

current->add("WarpingStiffness",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcConnectionGeometry] = new IfcEntityDescriptor(Type::IfcConnectionGeometry,0);

current = entity_descriptor_map[Type::IfcConnectionPointGeometry] = new IfcEntityDescriptor(Type::IfcConnectionPointGeometry,entity_descriptor_map.find(Type::IfcConnectionGeometry)->second);

current->add("PointOnRelatingElement",false,IfcUtil::Argument_ENTITY);

current->add("PointOnRelatedElement",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcConnectionSurfaceGeometry] = new IfcEntityDescriptor(Type::IfcConnectionSurfaceGeometry,entity_descriptor_map.find(Type::IfcConnectionGeometry)->second);

current->add("SurfaceOnRelatingElement",false,IfcUtil::Argument_ENTITY);

current->add("SurfaceOnRelatedElement",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcConnectionVolumeGeometry] = new IfcEntityDescriptor(Type::IfcConnectionVolumeGeometry,entity_descriptor_map.find(Type::IfcConnectionGeometry)->second);

current->add("VolumeOnRelatingElement",false,IfcUtil::Argument_ENTITY);

current->add("VolumeOnRelatedElement",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcConstraint] = new IfcEntityDescriptor(Type::IfcConstraint,0);

current->add("Name",false,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("ConstraintGrade",false,IfcUtil::Argument_ENUMERATION,Type::IfcConstraintEnum);

current->add("ConstraintSource",true,IfcUtil::Argument_STRING);

current->add("CreatingActor",true,IfcUtil::Argument_ENTITY);

current->add("CreationTime",true,IfcUtil::Argument_STRING);

current->add("UserDefinedGrade",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcCoordinateOperation] = new IfcEntityDescriptor(Type::IfcCoordinateOperation,0);

current->add("SourceCRS",false,IfcUtil::Argument_ENTITY);

current->add("TargetCRS",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcCoordinateReferenceSystem] = new IfcEntityDescriptor(Type::IfcCoordinateReferenceSystem,0);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("GeodeticDatum",false,IfcUtil::Argument_STRING);

current->add("VerticalDatum",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcCostValue] = new IfcEntityDescriptor(Type::IfcCostValue,entity_descriptor_map.find(Type::IfcAppliedValue)->second);

current = entity_descriptor_map[Type::IfcDerivedUnit] = new IfcEntityDescriptor(Type::IfcDerivedUnit,0);

current->add("Elements",false,IfcUtil::Argument_ENTITY_LIST);

current->add("UnitType",false,IfcUtil::Argument_ENUMERATION,Type::IfcDerivedUnitEnum);

current->add("UserDefinedType",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcDerivedUnitElement] = new IfcEntityDescriptor(Type::IfcDerivedUnitElement,0);

current->add("Unit",false,IfcUtil::Argument_ENTITY);

current->add("Exponent",false,IfcUtil::Argument_INT);

current = entity_descriptor_map[Type::IfcDimensionalExponents] = new IfcEntityDescriptor(Type::IfcDimensionalExponents,0);

current->add("LengthExponent",false,IfcUtil::Argument_INT);

current->add("MassExponent",false,IfcUtil::Argument_INT);

current->add("TimeExponent",false,IfcUtil::Argument_INT);

current->add("ElectricCurrentExponent",false,IfcUtil::Argument_INT);

current->add("ThermodynamicTemperatureExponent",false,IfcUtil::Argument_INT);

current->add("AmountOfSubstanceExponent",false,IfcUtil::Argument_INT);

current->add("LuminousIntensityExponent",false,IfcUtil::Argument_INT);

current = entity_descriptor_map[Type::IfcExternalInformation] = new IfcEntityDescriptor(Type::IfcExternalInformation,0);

current = entity_descriptor_map[Type::IfcExternalReference] = new IfcEntityDescriptor(Type::IfcExternalReference,0);

current->add("Location",true,IfcUtil::Argument_STRING);

current->add("Identification",true,IfcUtil::Argument_STRING);

current->add("Name",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcExternallyDefinedHatchStyle] = new IfcEntityDescriptor(Type::IfcExternallyDefinedHatchStyle,entity_descriptor_map.find(Type::IfcExternalReference)->second);

current = entity_descriptor_map[Type::IfcExternallyDefinedSurfaceStyle] = new IfcEntityDescriptor(Type::IfcExternallyDefinedSurfaceStyle,entity_descriptor_map.find(Type::IfcExternalReference)->second);

current = entity_descriptor_map[Type::IfcExternallyDefinedTextFont] = new IfcEntityDescriptor(Type::IfcExternallyDefinedTextFont,entity_descriptor_map.find(Type::IfcExternalReference)->second);

current = entity_descriptor_map[Type::IfcGridAxis] = new IfcEntityDescriptor(Type::IfcGridAxis,0);

current->add("AxisTag",true,IfcUtil::Argument_STRING);

current->add("AxisCurve",false,IfcUtil::Argument_ENTITY);

current->add("SameSense",false,IfcUtil::Argument_BOOL);

current = entity_descriptor_map[Type::IfcIrregularTimeSeriesValue] = new IfcEntityDescriptor(Type::IfcIrregularTimeSeriesValue,0);

current->add("TimeStamp",false,IfcUtil::Argument_STRING);

current->add("ListValues",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcLibraryInformation] = new IfcEntityDescriptor(Type::IfcLibraryInformation,entity_descriptor_map.find(Type::IfcExternalInformation)->second);

current->add("Name",false,IfcUtil::Argument_STRING);

current->add("Version",true,IfcUtil::Argument_STRING);

current->add("Publisher",true,IfcUtil::Argument_ENTITY);

current->add("VersionDate",true,IfcUtil::Argument_STRING);

current->add("Location",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcLibraryReference] = new IfcEntityDescriptor(Type::IfcLibraryReference,entity_descriptor_map.find(Type::IfcExternalReference)->second);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("Language",true,IfcUtil::Argument_STRING);

current->add("ReferencedLibrary",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcLightDistributionData] = new IfcEntityDescriptor(Type::IfcLightDistributionData,0);

current->add("MainPlaneAngle",false,IfcUtil::Argument_DOUBLE);

current->add("SecondaryPlaneAngle",false,IfcUtil::Argument_VECTOR_DOUBLE);

current->add("LuminousIntensity",false,IfcUtil::Argument_VECTOR_DOUBLE);

current = entity_descriptor_map[Type::IfcLightIntensityDistribution] = new IfcEntityDescriptor(Type::IfcLightIntensityDistribution,0);

current->add("LightDistributionCurve",false,IfcUtil::Argument_ENUMERATION,Type::IfcLightDistributionCurveEnum);

current->add("DistributionData",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcMapConversion] = new IfcEntityDescriptor(Type::IfcMapConversion,entity_descriptor_map.find(Type::IfcCoordinateOperation)->second);

current->add("Eastings",false,IfcUtil::Argument_DOUBLE);

current->add("Northings",false,IfcUtil::Argument_DOUBLE);

current->add("OrthogonalHeight",false,IfcUtil::Argument_DOUBLE);

current->add("XAxisAbscissa",true,IfcUtil::Argument_DOUBLE);

current->add("XAxisOrdinate",true,IfcUtil::Argument_DOUBLE);

current->add("Scale",true,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMaterialClassificationRelationship] = new IfcEntityDescriptor(Type::IfcMaterialClassificationRelationship,0);

current->add("MaterialClassifications",false,IfcUtil::Argument_ENTITY_LIST);

current->add("ClassifiedMaterial",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcMaterialDefinition] = new IfcEntityDescriptor(Type::IfcMaterialDefinition,0);

current = entity_descriptor_map[Type::IfcMaterialLayer] = new IfcEntityDescriptor(Type::IfcMaterialLayer,entity_descriptor_map.find(Type::IfcMaterialDefinition)->second);

current->add("Material",true,IfcUtil::Argument_ENTITY);

current->add("LayerThickness",false,IfcUtil::Argument_DOUBLE);

current->add("IsVentilated",true,IfcUtil::Argument_BOOL);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("Category",true,IfcUtil::Argument_STRING);

current->add("Priority",true,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcMaterialLayerSet] = new IfcEntityDescriptor(Type::IfcMaterialLayerSet,entity_descriptor_map.find(Type::IfcMaterialDefinition)->second);

current->add("MaterialLayers",false,IfcUtil::Argument_ENTITY_LIST);

current->add("LayerSetName",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcMaterialLayerWithOffsets] = new IfcEntityDescriptor(Type::IfcMaterialLayerWithOffsets,entity_descriptor_map.find(Type::IfcMaterialLayer)->second);

current->add("OffsetDirection",false,IfcUtil::Argument_ENUMERATION,Type::IfcLayerSetDirectionEnum);

current->add("OffsetValues",false,IfcUtil::Argument_VECTOR_DOUBLE);

current = entity_descriptor_map[Type::IfcMaterialList] = new IfcEntityDescriptor(Type::IfcMaterialList,0);

current->add("Materials",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcMaterialProfile] = new IfcEntityDescriptor(Type::IfcMaterialProfile,entity_descriptor_map.find(Type::IfcMaterialDefinition)->second);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("Material",true,IfcUtil::Argument_ENTITY);

current->add("Profile",false,IfcUtil::Argument_ENTITY);

current->add("Priority",true,IfcUtil::Argument_DOUBLE);

current->add("Category",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcMaterialProfileSet] = new IfcEntityDescriptor(Type::IfcMaterialProfileSet,entity_descriptor_map.find(Type::IfcMaterialDefinition)->second);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("MaterialProfiles",false,IfcUtil::Argument_ENTITY_LIST);

current->add("CompositeProfile",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcMaterialProfileWithOffsets] = new IfcEntityDescriptor(Type::IfcMaterialProfileWithOffsets,entity_descriptor_map.find(Type::IfcMaterialProfile)->second);

current->add("OffsetValues",false,IfcUtil::Argument_VECTOR_DOUBLE);

current = entity_descriptor_map[Type::IfcMaterialUsageDefinition] = new IfcEntityDescriptor(Type::IfcMaterialUsageDefinition,0);

current = entity_descriptor_map[Type::IfcMeasureWithUnit] = new IfcEntityDescriptor(Type::IfcMeasureWithUnit,0);

current->add("ValueComponent",false,IfcUtil::Argument_ENTITY);

current->add("UnitComponent",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcMetric] = new IfcEntityDescriptor(Type::IfcMetric,entity_descriptor_map.find(Type::IfcConstraint)->second);

current->add("Benchmark",false,IfcUtil::Argument_ENUMERATION,Type::IfcBenchmarkEnum);

current->add("ValueSource",true,IfcUtil::Argument_STRING);

current->add("DataValue",false,IfcUtil::Argument_ENTITY);

current->add("ReferencePath",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcMonetaryUnit] = new IfcEntityDescriptor(Type::IfcMonetaryUnit,0);

current->add("Currency",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcNamedUnit] = new IfcEntityDescriptor(Type::IfcNamedUnit,0);

current->add("Dimensions",false,IfcUtil::Argument_ENTITY);

current->add("UnitType",false,IfcUtil::Argument_ENUMERATION,Type::IfcUnitEnum);

current = entity_descriptor_map[Type::IfcObjectPlacement] = new IfcEntityDescriptor(Type::IfcObjectPlacement,0);

current = entity_descriptor_map[Type::IfcObjective] = new IfcEntityDescriptor(Type::IfcObjective,entity_descriptor_map.find(Type::IfcConstraint)->second);

current->add("BenchmarkValues",true,IfcUtil::Argument_ENTITY_LIST);

current->add("LogicalAggregator",true,IfcUtil::Argument_ENUMERATION,Type::IfcLogicalOperatorEnum);

current->add("ObjectiveQualifier",false,IfcUtil::Argument_ENUMERATION,Type::IfcObjectiveEnum);

current->add("UserDefinedQualifier",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcOrganization] = new IfcEntityDescriptor(Type::IfcOrganization,0);

current->add("Identification",true,IfcUtil::Argument_STRING);

current->add("Name",false,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("Roles",true,IfcUtil::Argument_ENTITY_LIST);

current->add("Addresses",true,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcOwnerHistory] = new IfcEntityDescriptor(Type::IfcOwnerHistory,0);

current->add("OwningUser",false,IfcUtil::Argument_ENTITY);

current->add("OwningApplication",false,IfcUtil::Argument_ENTITY);

current->add("State",true,IfcUtil::Argument_ENUMERATION,Type::IfcStateEnum);

current->add("ChangeAction",true,IfcUtil::Argument_ENUMERATION,Type::IfcChangeActionEnum);

current->add("LastModifiedDate",true,IfcUtil::Argument_INT);

current->add("LastModifyingUser",true,IfcUtil::Argument_ENTITY);

current->add("LastModifyingApplication",true,IfcUtil::Argument_ENTITY);

current->add("CreationDate",false,IfcUtil::Argument_INT);

current = entity_descriptor_map[Type::IfcPerson] = new IfcEntityDescriptor(Type::IfcPerson,0);

current->add("Identification",true,IfcUtil::Argument_STRING);

current->add("FamilyName",true,IfcUtil::Argument_STRING);

current->add("GivenName",true,IfcUtil::Argument_STRING);

current->add("MiddleNames",true,IfcUtil::Argument_VECTOR_STRING);

current->add("PrefixTitles",true,IfcUtil::Argument_VECTOR_STRING);

current->add("SuffixTitles",true,IfcUtil::Argument_VECTOR_STRING);

current->add("Roles",true,IfcUtil::Argument_ENTITY_LIST);

current->add("Addresses",true,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcPersonAndOrganization] = new IfcEntityDescriptor(Type::IfcPersonAndOrganization,0);

current->add("ThePerson",false,IfcUtil::Argument_ENTITY);

current->add("TheOrganization",false,IfcUtil::Argument_ENTITY);

current->add("Roles",true,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcPhysicalQuantity] = new IfcEntityDescriptor(Type::IfcPhysicalQuantity,0);

current->add("Name",false,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcPhysicalSimpleQuantity] = new IfcEntityDescriptor(Type::IfcPhysicalSimpleQuantity,entity_descriptor_map.find(Type::IfcPhysicalQuantity)->second);

current->add("Unit",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcPostalAddress] = new IfcEntityDescriptor(Type::IfcPostalAddress,entity_descriptor_map.find(Type::IfcAddress)->second);

current->add("InternalLocation",true,IfcUtil::Argument_STRING);

current->add("AddressLines",true,IfcUtil::Argument_VECTOR_STRING);

current->add("PostalBox",true,IfcUtil::Argument_STRING);

current->add("Town",true,IfcUtil::Argument_STRING);

current->add("Region",true,IfcUtil::Argument_STRING);

current->add("PostalCode",true,IfcUtil::Argument_STRING);

current->add("Country",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcPresentationItem] = new IfcEntityDescriptor(Type::IfcPresentationItem,0);

current = entity_descriptor_map[Type::IfcPresentationLayerAssignment] = new IfcEntityDescriptor(Type::IfcPresentationLayerAssignment,0);

current->add("Name",false,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("AssignedItems",false,IfcUtil::Argument_ENTITY_LIST);

current->add("Identifier",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcPresentationLayerWithStyle] = new IfcEntityDescriptor(Type::IfcPresentationLayerWithStyle,entity_descriptor_map.find(Type::IfcPresentationLayerAssignment)->second);

current->add("LayerOn",false,IfcUtil::Argument_BOOL);

current->add("LayerFrozen",false,IfcUtil::Argument_BOOL);

current->add("LayerBlocked",false,IfcUtil::Argument_BOOL);

current->add("LayerStyles",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcPresentationStyle] = new IfcEntityDescriptor(Type::IfcPresentationStyle,0);

current->add("Name",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcPresentationStyleAssignment] = new IfcEntityDescriptor(Type::IfcPresentationStyleAssignment,0);

current->add("Styles",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcProductRepresentation] = new IfcEntityDescriptor(Type::IfcProductRepresentation,0);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("Representations",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcProfileDef] = new IfcEntityDescriptor(Type::IfcProfileDef,0);

current->add("ProfileType",false,IfcUtil::Argument_ENUMERATION,Type::IfcProfileTypeEnum);

current->add("ProfileName",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcProjectedCRS] = new IfcEntityDescriptor(Type::IfcProjectedCRS,entity_descriptor_map.find(Type::IfcCoordinateReferenceSystem)->second);

current->add("MapProjection",true,IfcUtil::Argument_STRING);

current->add("MapZone",true,IfcUtil::Argument_STRING);

current->add("MapUnit",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcPropertyAbstraction] = new IfcEntityDescriptor(Type::IfcPropertyAbstraction,0);

current = entity_descriptor_map[Type::IfcPropertyEnumeration] = new IfcEntityDescriptor(Type::IfcPropertyEnumeration,entity_descriptor_map.find(Type::IfcPropertyAbstraction)->second);

current->add("Name",false,IfcUtil::Argument_STRING);

current->add("EnumerationValues",false,IfcUtil::Argument_ENTITY_LIST);

current->add("Unit",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcQuantityArea] = new IfcEntityDescriptor(Type::IfcQuantityArea,entity_descriptor_map.find(Type::IfcPhysicalSimpleQuantity)->second);

current->add("AreaValue",false,IfcUtil::Argument_DOUBLE);

current->add("Formula",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcQuantityCount] = new IfcEntityDescriptor(Type::IfcQuantityCount,entity_descriptor_map.find(Type::IfcPhysicalSimpleQuantity)->second);

current->add("CountValue",false,IfcUtil::Argument_DOUBLE);

current->add("Formula",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcQuantityLength] = new IfcEntityDescriptor(Type::IfcQuantityLength,entity_descriptor_map.find(Type::IfcPhysicalSimpleQuantity)->second);

current->add("LengthValue",false,IfcUtil::Argument_DOUBLE);

current->add("Formula",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcQuantityTime] = new IfcEntityDescriptor(Type::IfcQuantityTime,entity_descriptor_map.find(Type::IfcPhysicalSimpleQuantity)->second);

current->add("TimeValue",false,IfcUtil::Argument_DOUBLE);

current->add("Formula",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcQuantityVolume] = new IfcEntityDescriptor(Type::IfcQuantityVolume,entity_descriptor_map.find(Type::IfcPhysicalSimpleQuantity)->second);

current->add("VolumeValue",false,IfcUtil::Argument_DOUBLE);

current->add("Formula",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcQuantityWeight] = new IfcEntityDescriptor(Type::IfcQuantityWeight,entity_descriptor_map.find(Type::IfcPhysicalSimpleQuantity)->second);

current->add("WeightValue",false,IfcUtil::Argument_DOUBLE);

current->add("Formula",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcRecurrencePattern] = new IfcEntityDescriptor(Type::IfcRecurrencePattern,0);

current->add("RecurrenceType",false,IfcUtil::Argument_ENUMERATION,Type::IfcRecurrenceTypeEnum);

current->add("DayComponent",true,IfcUtil::Argument_VECTOR_INT);

current->add("WeekdayComponent",true,IfcUtil::Argument_VECTOR_INT);

current->add("MonthComponent",true,IfcUtil::Argument_VECTOR_INT);

current->add("Position",true,IfcUtil::Argument_INT);

current->add("Interval",true,IfcUtil::Argument_INT);

current->add("Occurrences",true,IfcUtil::Argument_INT);

current->add("TimePeriods",true,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcReference] = new IfcEntityDescriptor(Type::IfcReference,0);

current->add("TypeIdentifier",true,IfcUtil::Argument_STRING);

current->add("AttributeIdentifier",true,IfcUtil::Argument_STRING);

current->add("InstanceName",true,IfcUtil::Argument_STRING);

current->add("ListPositions",true,IfcUtil::Argument_VECTOR_INT);

current->add("InnerReference",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcRepresentation] = new IfcEntityDescriptor(Type::IfcRepresentation,0);

current->add("ContextOfItems",false,IfcUtil::Argument_ENTITY);

current->add("RepresentationIdentifier",true,IfcUtil::Argument_STRING);

current->add("RepresentationType",true,IfcUtil::Argument_STRING);

current->add("Items",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcRepresentationContext] = new IfcEntityDescriptor(Type::IfcRepresentationContext,0);

current->add("ContextIdentifier",true,IfcUtil::Argument_STRING);

current->add("ContextType",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcRepresentationItem] = new IfcEntityDescriptor(Type::IfcRepresentationItem,0);

current = entity_descriptor_map[Type::IfcRepresentationMap] = new IfcEntityDescriptor(Type::IfcRepresentationMap,0);

current->add("MappingOrigin",false,IfcUtil::Argument_ENTITY);

current->add("MappedRepresentation",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcResourceLevelRelationship] = new IfcEntityDescriptor(Type::IfcResourceLevelRelationship,0);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcRoot] = new IfcEntityDescriptor(Type::IfcRoot,0);

current->add("GlobalId",false,IfcUtil::Argument_STRING);

current->add("OwnerHistory",true,IfcUtil::Argument_ENTITY);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcSIUnit] = new IfcEntityDescriptor(Type::IfcSIUnit,entity_descriptor_map.find(Type::IfcNamedUnit)->second);

current->add("Prefix",true,IfcUtil::Argument_ENUMERATION,Type::IfcSIPrefix);

current->add("Name",false,IfcUtil::Argument_ENUMERATION,Type::IfcSIUnitName);

current = entity_descriptor_map[Type::IfcSchedulingTime] = new IfcEntityDescriptor(Type::IfcSchedulingTime,0);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("DataOrigin",true,IfcUtil::Argument_ENUMERATION,Type::IfcDataOriginEnum);

current->add("UserDefinedDataOrigin",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcShapeAspect] = new IfcEntityDescriptor(Type::IfcShapeAspect,0);

current->add("ShapeRepresentations",false,IfcUtil::Argument_ENTITY_LIST);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("ProductDefinitional",false,IfcUtil::Argument_BOOL);

current->add("PartOfProductDefinitionShape",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcShapeModel] = new IfcEntityDescriptor(Type::IfcShapeModel,entity_descriptor_map.find(Type::IfcRepresentation)->second);

current = entity_descriptor_map[Type::IfcShapeRepresentation] = new IfcEntityDescriptor(Type::IfcShapeRepresentation,entity_descriptor_map.find(Type::IfcShapeModel)->second);

current = entity_descriptor_map[Type::IfcStructuralConnectionCondition] = new IfcEntityDescriptor(Type::IfcStructuralConnectionCondition,0);

current->add("Name",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcStructuralLoad] = new IfcEntityDescriptor(Type::IfcStructuralLoad,0);

current->add("Name",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcStructuralLoadConfiguration] = new IfcEntityDescriptor(Type::IfcStructuralLoadConfiguration,entity_descriptor_map.find(Type::IfcStructuralLoad)->second);

current->add("Values",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcStructuralLoadOrResult] = new IfcEntityDescriptor(Type::IfcStructuralLoadOrResult,entity_descriptor_map.find(Type::IfcStructuralLoad)->second);

current = entity_descriptor_map[Type::IfcStructuralLoadStatic] = new IfcEntityDescriptor(Type::IfcStructuralLoadStatic,entity_descriptor_map.find(Type::IfcStructuralLoadOrResult)->second);

current = entity_descriptor_map[Type::IfcStructuralLoadTemperature] = new IfcEntityDescriptor(Type::IfcStructuralLoadTemperature,entity_descriptor_map.find(Type::IfcStructuralLoadStatic)->second);

current->add("DeltaTConstant",true,IfcUtil::Argument_DOUBLE);

current->add("DeltaTY",true,IfcUtil::Argument_DOUBLE);

current->add("DeltaTZ",true,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcStyleModel] = new IfcEntityDescriptor(Type::IfcStyleModel,entity_descriptor_map.find(Type::IfcRepresentation)->second);

current = entity_descriptor_map[Type::IfcStyledItem] = new IfcEntityDescriptor(Type::IfcStyledItem,entity_descriptor_map.find(Type::IfcRepresentationItem)->second);

current->add("Item",true,IfcUtil::Argument_ENTITY);

current->add("Styles",false,IfcUtil::Argument_ENTITY_LIST);

current->add("Name",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcStyledRepresentation] = new IfcEntityDescriptor(Type::IfcStyledRepresentation,entity_descriptor_map.find(Type::IfcStyleModel)->second);

current = entity_descriptor_map[Type::IfcSurfaceReinforcementArea] = new IfcEntityDescriptor(Type::IfcSurfaceReinforcementArea,entity_descriptor_map.find(Type::IfcStructuralLoadOrResult)->second);

current->add("SurfaceReinforcement1",true,IfcUtil::Argument_VECTOR_DOUBLE);

current->add("SurfaceReinforcement2",true,IfcUtil::Argument_VECTOR_DOUBLE);

current->add("ShearReinforcement",true,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSurfaceStyle] = new IfcEntityDescriptor(Type::IfcSurfaceStyle,entity_descriptor_map.find(Type::IfcPresentationStyle)->second);

current->add("Side",false,IfcUtil::Argument_ENUMERATION,Type::IfcSurfaceSide);

current->add("Styles",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcSurfaceStyleLighting] = new IfcEntityDescriptor(Type::IfcSurfaceStyleLighting,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("DiffuseTransmissionColour",false,IfcUtil::Argument_ENTITY);

current->add("DiffuseReflectionColour",false,IfcUtil::Argument_ENTITY);

current->add("TransmissionColour",false,IfcUtil::Argument_ENTITY);

current->add("ReflectanceColour",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcSurfaceStyleRefraction] = new IfcEntityDescriptor(Type::IfcSurfaceStyleRefraction,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("RefractionIndex",true,IfcUtil::Argument_DOUBLE);

current->add("DispersionFactor",true,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcSurfaceStyleShading] = new IfcEntityDescriptor(Type::IfcSurfaceStyleShading,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("SurfaceColour",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcSurfaceStyleWithTextures] = new IfcEntityDescriptor(Type::IfcSurfaceStyleWithTextures,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("Textures",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcSurfaceTexture] = new IfcEntityDescriptor(Type::IfcSurfaceTexture,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("RepeatS",false,IfcUtil::Argument_BOOL);

current->add("RepeatT",false,IfcUtil::Argument_BOOL);

current->add("Mode",true,IfcUtil::Argument_STRING);

current->add("TextureTransform",true,IfcUtil::Argument_ENTITY);

current->add("Parameter",true,IfcUtil::Argument_VECTOR_STRING);

current = entity_descriptor_map[Type::IfcTable] = new IfcEntityDescriptor(Type::IfcTable,0);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Rows",true,IfcUtil::Argument_ENTITY_LIST);

current->add("Columns",true,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcTableColumn] = new IfcEntityDescriptor(Type::IfcTableColumn,0);

current->add("Identifier",true,IfcUtil::Argument_STRING);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("Unit",true,IfcUtil::Argument_ENTITY);

current->add("ReferencePath",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcTableRow] = new IfcEntityDescriptor(Type::IfcTableRow,0);

current->add("RowCells",true,IfcUtil::Argument_ENTITY_LIST);

current->add("IsHeading",true,IfcUtil::Argument_BOOL);

current = entity_descriptor_map[Type::IfcTaskTime] = new IfcEntityDescriptor(Type::IfcTaskTime,entity_descriptor_map.find(Type::IfcSchedulingTime)->second);

current->add("DurationType",true,IfcUtil::Argument_ENUMERATION,Type::IfcTaskDurationEnum);

current->add("ScheduleDuration",true,IfcUtil::Argument_STRING);

current->add("ScheduleStart",true,IfcUtil::Argument_STRING);

current->add("ScheduleFinish",true,IfcUtil::Argument_STRING);

current->add("EarlyStart",true,IfcUtil::Argument_STRING);

current->add("EarlyFinish",true,IfcUtil::Argument_STRING);

current->add("LateStart",true,IfcUtil::Argument_STRING);

current->add("LateFinish",true,IfcUtil::Argument_STRING);

current->add("FreeFloat",true,IfcUtil::Argument_STRING);

current->add("TotalFloat",true,IfcUtil::Argument_STRING);

current->add("IsCritical",true,IfcUtil::Argument_BOOL);

current->add("StatusTime",true,IfcUtil::Argument_STRING);

current->add("ActualDuration",true,IfcUtil::Argument_STRING);

current->add("ActualStart",true,IfcUtil::Argument_STRING);

current->add("ActualFinish",true,IfcUtil::Argument_STRING);

current->add("RemainingTime",true,IfcUtil::Argument_STRING);

current->add("Completion",true,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcTaskTimeRecurring] = new IfcEntityDescriptor(Type::IfcTaskTimeRecurring,entity_descriptor_map.find(Type::IfcTaskTime)->second);

current->add("Recurrance",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcTelecomAddress] = new IfcEntityDescriptor(Type::IfcTelecomAddress,entity_descriptor_map.find(Type::IfcAddress)->second);

current->add("TelephoneNumbers",true,IfcUtil::Argument_VECTOR_STRING);

current->add("FacsimileNumbers",true,IfcUtil::Argument_VECTOR_STRING);

current->add("PagerNumber",true,IfcUtil::Argument_STRING);

current->add("ElectronicMailAddresses",true,IfcUtil::Argument_VECTOR_STRING);

current->add("WWWHomePageURL",true,IfcUtil::Argument_STRING);

current->add("MessagingIDs",true,IfcUtil::Argument_VECTOR_STRING);

current = entity_descriptor_map[Type::IfcTextStyle] = new IfcEntityDescriptor(Type::IfcTextStyle,entity_descriptor_map.find(Type::IfcPresentationStyle)->second);

current->add("TextCharacterAppearance",true,IfcUtil::Argument_ENTITY);

current->add("TextStyle",true,IfcUtil::Argument_ENTITY);

current->add("TextFontStyle",false,IfcUtil::Argument_ENTITY);

current->add("ModelOrDraughting",true,IfcUtil::Argument_BOOL);

current = entity_descriptor_map[Type::IfcTextStyleForDefinedFont] = new IfcEntityDescriptor(Type::IfcTextStyleForDefinedFont,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("Colour",false,IfcUtil::Argument_ENTITY);

current->add("BackgroundColour",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcTextStyleTextModel] = new IfcEntityDescriptor(Type::IfcTextStyleTextModel,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("TextIndent",true,IfcUtil::Argument_ENTITY);

current->add("TextAlign",true,IfcUtil::Argument_STRING);

current->add("TextDecoration",true,IfcUtil::Argument_STRING);

current->add("LetterSpacing",true,IfcUtil::Argument_ENTITY);

current->add("WordSpacing",true,IfcUtil::Argument_ENTITY);

current->add("TextTransform",true,IfcUtil::Argument_STRING);

current->add("LineHeight",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcTextureCoordinate] = new IfcEntityDescriptor(Type::IfcTextureCoordinate,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("Maps",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcTextureCoordinateGenerator] = new IfcEntityDescriptor(Type::IfcTextureCoordinateGenerator,entity_descriptor_map.find(Type::IfcTextureCoordinate)->second);

current->add("Mode",false,IfcUtil::Argument_STRING);

current->add("Parameter",true,IfcUtil::Argument_VECTOR_DOUBLE);

current = entity_descriptor_map[Type::IfcTextureMap] = new IfcEntityDescriptor(Type::IfcTextureMap,entity_descriptor_map.find(Type::IfcTextureCoordinate)->second);

current->add("Vertices",false,IfcUtil::Argument_ENTITY_LIST);

current->add("MappedTo",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcTextureVertex] = new IfcEntityDescriptor(Type::IfcTextureVertex,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("Coordinates",false,IfcUtil::Argument_VECTOR_DOUBLE);

current = entity_descriptor_map[Type::IfcTextureVertexList] = new IfcEntityDescriptor(Type::IfcTextureVertexList,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current = entity_descriptor_map[Type::IfcTimePeriod] = new IfcEntityDescriptor(Type::IfcTimePeriod,0);

current->add("StartTime",false,IfcUtil::Argument_STRING);

current->add("EndTime",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcTimeSeries] = new IfcEntityDescriptor(Type::IfcTimeSeries,0);

current->add("Name",false,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("StartTime",false,IfcUtil::Argument_STRING);

current->add("EndTime",false,IfcUtil::Argument_STRING);

current->add("TimeSeriesDataType",false,IfcUtil::Argument_ENUMERATION,Type::IfcTimeSeriesDataTypeEnum);

current->add("DataOrigin",false,IfcUtil::Argument_ENUMERATION,Type::IfcDataOriginEnum);

current->add("UserDefinedDataOrigin",true,IfcUtil::Argument_STRING);

current->add("Unit",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcTimeSeriesValue] = new IfcEntityDescriptor(Type::IfcTimeSeriesValue,0);

current->add("ListValues",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcTopologicalRepresentationItem] = new IfcEntityDescriptor(Type::IfcTopologicalRepresentationItem,entity_descriptor_map.find(Type::IfcRepresentationItem)->second);

current = entity_descriptor_map[Type::IfcTopologyRepresentation] = new IfcEntityDescriptor(Type::IfcTopologyRepresentation,entity_descriptor_map.find(Type::IfcShapeModel)->second);

current = entity_descriptor_map[Type::IfcUnitAssignment] = new IfcEntityDescriptor(Type::IfcUnitAssignment,0);

current->add("Units",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcVertex] = new IfcEntityDescriptor(Type::IfcVertex,entity_descriptor_map.find(Type::IfcTopologicalRepresentationItem)->second);

current = entity_descriptor_map[Type::IfcVertexPoint] = new IfcEntityDescriptor(Type::IfcVertexPoint,entity_descriptor_map.find(Type::IfcVertex)->second);

current->add("VertexGeometry",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcVirtualGridIntersection] = new IfcEntityDescriptor(Type::IfcVirtualGridIntersection,0);

current->add("IntersectingAxes",false,IfcUtil::Argument_ENTITY_LIST);

current->add("OffsetDistances",false,IfcUtil::Argument_VECTOR_DOUBLE);

current = entity_descriptor_map[Type::IfcWorkTime] = new IfcEntityDescriptor(Type::IfcWorkTime,entity_descriptor_map.find(Type::IfcSchedulingTime)->second);

current->add("RecurrencePattern",true,IfcUtil::Argument_ENTITY);

current->add("Start",true,IfcUtil::Argument_STRING);

current->add("Finish",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcApprovalRelationship] = new IfcEntityDescriptor(Type::IfcApprovalRelationship,entity_descriptor_map.find(Type::IfcResourceLevelRelationship)->second);

current->add("RelatingApproval",false,IfcUtil::Argument_ENTITY);

current->add("RelatedApprovals",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcArbitraryClosedProfileDef] = new IfcEntityDescriptor(Type::IfcArbitraryClosedProfileDef,entity_descriptor_map.find(Type::IfcProfileDef)->second);

current->add("OuterCurve",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcArbitraryOpenProfileDef] = new IfcEntityDescriptor(Type::IfcArbitraryOpenProfileDef,entity_descriptor_map.find(Type::IfcProfileDef)->second);

current->add("Curve",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcArbitraryProfileDefWithVoids] = new IfcEntityDescriptor(Type::IfcArbitraryProfileDefWithVoids,entity_descriptor_map.find(Type::IfcArbitraryClosedProfileDef)->second);

current->add("InnerCurves",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcBlobTexture] = new IfcEntityDescriptor(Type::IfcBlobTexture,entity_descriptor_map.find(Type::IfcSurfaceTexture)->second);

current->add("RasterFormat",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcCenterLineProfileDef] = new IfcEntityDescriptor(Type::IfcCenterLineProfileDef,entity_descriptor_map.find(Type::IfcArbitraryOpenProfileDef)->second);

current->add("Thickness",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcClassification] = new IfcEntityDescriptor(Type::IfcClassification,entity_descriptor_map.find(Type::IfcExternalInformation)->second);

current->add("Source",true,IfcUtil::Argument_STRING);

current->add("Edition",true,IfcUtil::Argument_STRING);

current->add("EditionDate",true,IfcUtil::Argument_STRING);

current->add("Name",false,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("Location",true,IfcUtil::Argument_STRING);

current->add("ReferenceTokens",true,IfcUtil::Argument_VECTOR_STRING);

current = entity_descriptor_map[Type::IfcClassificationReference] = new IfcEntityDescriptor(Type::IfcClassificationReference,entity_descriptor_map.find(Type::IfcExternalReference)->second);

current->add("ReferencedSource",true,IfcUtil::Argument_ENTITY);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("Sort",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcColourRgbList] = new IfcEntityDescriptor(Type::IfcColourRgbList,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current = entity_descriptor_map[Type::IfcColourSpecification] = new IfcEntityDescriptor(Type::IfcColourSpecification,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("Name",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcCompositeProfileDef] = new IfcEntityDescriptor(Type::IfcCompositeProfileDef,entity_descriptor_map.find(Type::IfcProfileDef)->second);

current->add("Profiles",false,IfcUtil::Argument_ENTITY_LIST);

current->add("Label",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcConnectedFaceSet] = new IfcEntityDescriptor(Type::IfcConnectedFaceSet,entity_descriptor_map.find(Type::IfcTopologicalRepresentationItem)->second);

current->add("CfsFaces",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcConnectionCurveGeometry] = new IfcEntityDescriptor(Type::IfcConnectionCurveGeometry,entity_descriptor_map.find(Type::IfcConnectionGeometry)->second);

current->add("CurveOnRelatingElement",false,IfcUtil::Argument_ENTITY);

current->add("CurveOnRelatedElement",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcConnectionPointEccentricity] = new IfcEntityDescriptor(Type::IfcConnectionPointEccentricity,entity_descriptor_map.find(Type::IfcConnectionPointGeometry)->second);

current->add("EccentricityInX",true,IfcUtil::Argument_DOUBLE);

current->add("EccentricityInY",true,IfcUtil::Argument_DOUBLE);

current->add("EccentricityInZ",true,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcContextDependentUnit] = new IfcEntityDescriptor(Type::IfcContextDependentUnit,entity_descriptor_map.find(Type::IfcNamedUnit)->second);

current->add("Name",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcConversionBasedUnit] = new IfcEntityDescriptor(Type::IfcConversionBasedUnit,entity_descriptor_map.find(Type::IfcNamedUnit)->second);

current->add("Name",false,IfcUtil::Argument_STRING);

current->add("ConversionFactor",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcConversionBasedUnitWithOffset] = new IfcEntityDescriptor(Type::IfcConversionBasedUnitWithOffset,entity_descriptor_map.find(Type::IfcConversionBasedUnit)->second);

current->add("ConversionOffset",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcCurrencyRelationship] = new IfcEntityDescriptor(Type::IfcCurrencyRelationship,entity_descriptor_map.find(Type::IfcResourceLevelRelationship)->second);

current->add("RelatingMonetaryUnit",false,IfcUtil::Argument_ENTITY);

current->add("RelatedMonetaryUnit",false,IfcUtil::Argument_ENTITY);

current->add("ExchangeRate",false,IfcUtil::Argument_DOUBLE);

current->add("RateDateTime",true,IfcUtil::Argument_STRING);

current->add("RateSource",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcCurveStyle] = new IfcEntityDescriptor(Type::IfcCurveStyle,entity_descriptor_map.find(Type::IfcPresentationStyle)->second);

current->add("CurveFont",true,IfcUtil::Argument_ENTITY);

current->add("CurveWidth",true,IfcUtil::Argument_ENTITY);

current->add("CurveColour",true,IfcUtil::Argument_ENTITY);

current->add("ModelOrDraughting",true,IfcUtil::Argument_BOOL);

current = entity_descriptor_map[Type::IfcCurveStyleFont] = new IfcEntityDescriptor(Type::IfcCurveStyleFont,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("PatternList",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcCurveStyleFontAndScaling] = new IfcEntityDescriptor(Type::IfcCurveStyleFontAndScaling,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("CurveFont",false,IfcUtil::Argument_ENTITY);

current->add("CurveFontScaling",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcCurveStyleFontPattern] = new IfcEntityDescriptor(Type::IfcCurveStyleFontPattern,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("VisibleSegmentLength",false,IfcUtil::Argument_DOUBLE);

current->add("InvisibleSegmentLength",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcDerivedProfileDef] = new IfcEntityDescriptor(Type::IfcDerivedProfileDef,entity_descriptor_map.find(Type::IfcProfileDef)->second);

current->add("ParentProfile",false,IfcUtil::Argument_ENTITY);

current->add("Operator",false,IfcUtil::Argument_ENTITY);

current->add("Label",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcDocumentInformation] = new IfcEntityDescriptor(Type::IfcDocumentInformation,entity_descriptor_map.find(Type::IfcExternalInformation)->second);

current->add("Identification",false,IfcUtil::Argument_STRING);

current->add("Name",false,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("Location",true,IfcUtil::Argument_STRING);

current->add("Purpose",true,IfcUtil::Argument_STRING);

current->add("IntendedUse",true,IfcUtil::Argument_STRING);

current->add("Scope",true,IfcUtil::Argument_STRING);

current->add("Revision",true,IfcUtil::Argument_STRING);

current->add("DocumentOwner",true,IfcUtil::Argument_ENTITY);

current->add("Editors",true,IfcUtil::Argument_ENTITY_LIST);

current->add("CreationTime",true,IfcUtil::Argument_STRING);

current->add("LastRevisionTime",true,IfcUtil::Argument_STRING);

current->add("ElectronicFormat",true,IfcUtil::Argument_STRING);

current->add("ValidFrom",true,IfcUtil::Argument_STRING);

current->add("ValidUntil",true,IfcUtil::Argument_STRING);

current->add("Confidentiality",true,IfcUtil::Argument_ENUMERATION,Type::IfcDocumentConfidentialityEnum);

current->add("Status",true,IfcUtil::Argument_ENUMERATION,Type::IfcDocumentStatusEnum);

current = entity_descriptor_map[Type::IfcDocumentInformationRelationship] = new IfcEntityDescriptor(Type::IfcDocumentInformationRelationship,entity_descriptor_map.find(Type::IfcResourceLevelRelationship)->second);

current->add("RelatingDocument",false,IfcUtil::Argument_ENTITY);

current->add("RelatedDocuments",false,IfcUtil::Argument_ENTITY_LIST);

current->add("RelationshipType",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcDocumentReference] = new IfcEntityDescriptor(Type::IfcDocumentReference,entity_descriptor_map.find(Type::IfcExternalReference)->second);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("ReferencedDocument",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcEdge] = new IfcEntityDescriptor(Type::IfcEdge,entity_descriptor_map.find(Type::IfcTopologicalRepresentationItem)->second);

current->add("EdgeStart",false,IfcUtil::Argument_ENTITY);

current->add("EdgeEnd",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcEdgeCurve] = new IfcEntityDescriptor(Type::IfcEdgeCurve,entity_descriptor_map.find(Type::IfcEdge)->second);

current->add("EdgeGeometry",false,IfcUtil::Argument_ENTITY);

current->add("SameSense",false,IfcUtil::Argument_BOOL);

current = entity_descriptor_map[Type::IfcEventTime] = new IfcEntityDescriptor(Type::IfcEventTime,entity_descriptor_map.find(Type::IfcSchedulingTime)->second);

current->add("ActualDate",true,IfcUtil::Argument_STRING);

current->add("EarlyDate",true,IfcUtil::Argument_STRING);

current->add("LateDate",true,IfcUtil::Argument_STRING);

current->add("ScheduleDate",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcExtendedProperties] = new IfcEntityDescriptor(Type::IfcExtendedProperties,entity_descriptor_map.find(Type::IfcPropertyAbstraction)->second);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("Description",true,IfcUtil::Argument_STRING);

current->add("Properties",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcExternalReferenceRelationship] = new IfcEntityDescriptor(Type::IfcExternalReferenceRelationship,entity_descriptor_map.find(Type::IfcResourceLevelRelationship)->second);

current->add("RelatingReference",false,IfcUtil::Argument_ENTITY);

current->add("RelatedResourceObjects",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcFace] = new IfcEntityDescriptor(Type::IfcFace,entity_descriptor_map.find(Type::IfcTopologicalRepresentationItem)->second);

current->add("Bounds",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcFaceBound] = new IfcEntityDescriptor(Type::IfcFaceBound,entity_descriptor_map.find(Type::IfcTopologicalRepresentationItem)->second);

current->add("Bound",false,IfcUtil::Argument_ENTITY);

current->add("Orientation",false,IfcUtil::Argument_BOOL);

current = entity_descriptor_map[Type::IfcFaceOuterBound] = new IfcEntityDescriptor(Type::IfcFaceOuterBound,entity_descriptor_map.find(Type::IfcFaceBound)->second);

current = entity_descriptor_map[Type::IfcFaceSurface] = new IfcEntityDescriptor(Type::IfcFaceSurface,entity_descriptor_map.find(Type::IfcFace)->second);

current->add("FaceSurface",false,IfcUtil::Argument_ENTITY);

current->add("SameSense",false,IfcUtil::Argument_BOOL);

current = entity_descriptor_map[Type::IfcFailureConnectionCondition] = new IfcEntityDescriptor(Type::IfcFailureConnectionCondition,entity_descriptor_map.find(Type::IfcStructuralConnectionCondition)->second);

current->add("TensionFailureX",true,IfcUtil::Argument_DOUBLE);

current->add("TensionFailureY",true,IfcUtil::Argument_DOUBLE);

current->add("TensionFailureZ",true,IfcUtil::Argument_DOUBLE);

current->add("CompressionFailureX",true,IfcUtil::Argument_DOUBLE);

current->add("CompressionFailureY",true,IfcUtil::Argument_DOUBLE);

current->add("CompressionFailureZ",true,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcFillAreaStyle] = new IfcEntityDescriptor(Type::IfcFillAreaStyle,entity_descriptor_map.find(Type::IfcPresentationStyle)->second);

current->add("FillStyles",false,IfcUtil::Argument_ENTITY_LIST);

current->add("ModelorDraughting",true,IfcUtil::Argument_BOOL);

current = entity_descriptor_map[Type::IfcGeometricRepresentationContext] = new IfcEntityDescriptor(Type::IfcGeometricRepresentationContext,entity_descriptor_map.find(Type::IfcRepresentationContext)->second);

current->add("CoordinateSpaceDimension",false,IfcUtil::Argument_INT);

current->add("Precision",true,IfcUtil::Argument_DOUBLE);

current->add("WorldCoordinateSystem",false,IfcUtil::Argument_ENTITY);

current->add("TrueNorth",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcGeometricRepresentationItem] = new IfcEntityDescriptor(Type::IfcGeometricRepresentationItem,entity_descriptor_map.find(Type::IfcRepresentationItem)->second);

current = entity_descriptor_map[Type::IfcGeometricRepresentationSubContext] = new IfcEntityDescriptor(Type::IfcGeometricRepresentationSubContext,entity_descriptor_map.find(Type::IfcGeometricRepresentationContext)->second);

current->add("ParentContext",false,IfcUtil::Argument_ENTITY);

current->add("TargetScale",true,IfcUtil::Argument_DOUBLE);

current->add("TargetView",false,IfcUtil::Argument_ENUMERATION,Type::IfcGeometricProjectionEnum);

current->add("UserDefinedTargetView",true,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcGeometricSet] = new IfcEntityDescriptor(Type::IfcGeometricSet,entity_descriptor_map.find(Type::IfcGeometricRepresentationItem)->second);

current->add("Elements",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcGridPlacement] = new IfcEntityDescriptor(Type::IfcGridPlacement,entity_descriptor_map.find(Type::IfcObjectPlacement)->second);

current->add("PlacementLocation",false,IfcUtil::Argument_ENTITY);

current->add("PlacementRefDirection",true,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcHalfSpaceSolid] = new IfcEntityDescriptor(Type::IfcHalfSpaceSolid,entity_descriptor_map.find(Type::IfcGeometricRepresentationItem)->second);

current->add("BaseSurface",false,IfcUtil::Argument_ENTITY);

current->add("AgreementFlag",false,IfcUtil::Argument_BOOL);

current = entity_descriptor_map[Type::IfcImageTexture] = new IfcEntityDescriptor(Type::IfcImageTexture,entity_descriptor_map.find(Type::IfcSurfaceTexture)->second);

current->add("URLReference",false,IfcUtil::Argument_STRING);

current = entity_descriptor_map[Type::IfcIndexedColourMap] = new IfcEntityDescriptor(Type::IfcIndexedColourMap,entity_descriptor_map.find(Type::IfcPresentationItem)->second);

current->add("MappedTo",false,IfcUtil::Argument_ENTITY);

current->add("Overrides",true,IfcUtil::Argument_ENTITY);

current->add("Colours",false,IfcUtil::Argument_ENTITY);

current->add("ColourIndex",false,IfcUtil::Argument_VECTOR_INT);

current = entity_descriptor_map[Type::IfcIndexedTextureMap] = new IfcEntityDescriptor(Type::IfcIndexedTextureMap,entity_descriptor_map.find(Type::IfcTextureCoordinate)->second);

current->add("MappedTo",false,IfcUtil::Argument_ENTITY);

current->add("TexCoords",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcIndexedTriangleTextureMap] = new IfcEntityDescriptor(Type::IfcIndexedTriangleTextureMap,entity_descriptor_map.find(Type::IfcIndexedTextureMap)->second);

current = entity_descriptor_map[Type::IfcIrregularTimeSeries] = new IfcEntityDescriptor(Type::IfcIrregularTimeSeries,entity_descriptor_map.find(Type::IfcTimeSeries)->second);

current->add("Values",false,IfcUtil::Argument_ENTITY_LIST);

current = entity_descriptor_map[Type::IfcLagTime] = new IfcEntityDescriptor(Type::IfcLagTime,entity_descriptor_map.find(Type::IfcSchedulingTime)->second);

current->add("LagValue",false,IfcUtil::Argument_ENTITY);

current->add("DurationType",false,IfcUtil::Argument_ENUMERATION,Type::IfcTaskDurationEnum);

current = entity_descriptor_map[Type::IfcLightSource] = new IfcEntityDescriptor(Type::IfcLightSource,entity_descriptor_map.find(Type::IfcGeometricRepresentationItem)->second);

current->add("Name",true,IfcUtil::Argument_STRING);

current->add("LightColour",false,IfcUtil::Argument_ENTITY);

current->add("AmbientIntensity",true,IfcUtil::Argument_DOUBLE);

current->add("Intensity",true,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcLightSourceAmbient] = new IfcEntityDescriptor(Type::IfcLightSourceAmbient,entity_descriptor_map.find(Type::IfcLightSource)->second);

current = entity_descriptor_map[Type::IfcLightSourceDirectional] = new IfcEntityDescriptor(Type::IfcLightSourceDirectional,entity_descriptor_map.find(Type::IfcLightSource)->second);

current->add("Orientation",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcLightSourceGoniometric] = new IfcEntityDescriptor(Type::IfcLightSourceGoniometric,entity_descriptor_map.find(Type::IfcLightSource)->second);

current->add("Position",false,IfcUtil::Argument_ENTITY);

current->add("ColourAppearance",true,IfcUtil::Argument_ENTITY);

current->add("ColourTemperature",false,IfcUtil::Argument_DOUBLE);

current->add("LuminousFlux",false,IfcUtil::Argument_DOUBLE);

current->add("LightEmissionSource",false,IfcUtil::Argument_ENUMERATION,Type::IfcLightEmissionSourceEnum);

current->add("LightDistributionDataSource",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcLightSourcePositional] = new IfcEntityDescriptor(Type::IfcLightSourcePositional,entity_descriptor_map.find(Type::IfcLightSource)->second);

current->add("Position",false,IfcUtil::Argument_ENTITY);

current->add("Radius",false,IfcUtil::Argument_DOUBLE);

current->add("ConstantAttenuation",false,IfcUtil::Argument_DOUBLE);

current->add("DistanceAttenuation",false,IfcUtil::Argument_DOUBLE);

current->add("QuadricAttenuation",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcLightSourceSpot] = new IfcEntityDescriptor(Type::IfcLightSourceSpot,entity_descriptor_map.find(Type::IfcLightSourcePositional)->second);

current->add("Orientation",false,IfcUtil::Argument_ENTITY);

current->add("ConcentrationExponent",true,IfcUtil::Argument_DOUBLE);

current->add("SpreadAngle",false,IfcUtil::Argument_DOUBLE);

current->add("BeamWidthAngle",false,IfcUtil::Argument_DOUBLE);

current = entity_descriptor_map[Type::IfcLocalPlacement] = new IfcEntityDescriptor(Type::IfcLocalPlacement,entity_descriptor_map.find(Type::IfcObjectPlacement)->second);

current->add("PlacementRelTo",true,IfcUtil::Argument_ENTITY);

current->add("RelativePlacement",false,IfcUtil::Argument_ENTITY);

current = entity_descriptor_map[Type::IfcLoop] = new IfcEntityDescriptor(Type::IfcLoop,entity_descriptor_map.find(Type::IfcTopologicalRepresentationItem)->second);