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

* *

* 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 IFC2X3_TC1.exp. Do not make modifications *

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

* *

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

#ifndef USE_IFC4

#include <set>

#include "../ifcparse/Ifc2x3.h"

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

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

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

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

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

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

using namespace Ifc2x3;

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::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::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::IfcDayInMonthNumber] = new IfcEntityDescriptor(Type::IfcDayInMonthNumber,0);

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

current = entity_descriptor_map[Type::IfcDaylightSavingHour] = new IfcEntityDescriptor(Type::IfcDaylightSavingHour,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::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::IfcHourInDay] = new IfcEntityDescriptor(Type::IfcHourInDay,0);

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

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::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::IfcMinuteInHour] = new IfcEntityDescriptor(Type::IfcMinuteInHour,0);

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

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::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::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::IfcSecondInMinute] = new IfcEntityDescriptor(Type::IfcSecondInMinute,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::IfcSoundPowerMeasure] = new IfcEntityDescriptor(Type::IfcSoundPowerMeasure,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::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::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::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::IfcYearNumber] = new IfcEntityDescriptor(Type::IfcYearNumber,0);

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

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_ENTITY);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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("LinearStiffnessByLengthX",true,IfcUtil::Argument_DOUBLE);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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::IfcConnectionPortGeometry] = new IfcEntityDescriptor(Type::IfcConnectionPortGeometry,entity_descriptor_map.find(Type::IfcConnectionGeometry)->second);

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

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

current->add("ProfileOfPort",false,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::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_ENTITY);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

current->add("Sense",false,IfcUtil::Argument_ENUMERATION,Type::IfcAheadOrBehind);

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

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

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

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

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

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

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

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

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

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

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,0);

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,0);

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

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

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

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

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

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::IfcDocumentElectronicFormat] = new IfcEntityDescriptor(Type::IfcDocumentElectronicFormat,0);

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

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

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

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

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

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

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

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

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_ENTITY);

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

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

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

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

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,0);

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::IfcDraughtingCalloutRelationship] = new IfcEntityDescriptor(Type::IfcDraughtingCalloutRelationship,0);

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

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

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

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

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

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

current->add("Category",false,IfcUtil::Argument_ENUMERATION,Type::IfcEnvironmentalImpactCategoryEnum);

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

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

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

current->add("ItemReference",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::IfcExternallyDefinedSymbol] = new IfcEntityDescriptor(Type::IfcExternallyDefinedSymbol,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_ENTITY);

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

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

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_ENTITY);

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

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

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::IfcLocalTime] = new IfcEntityDescriptor(Type::IfcLocalTime,0);

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

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

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

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

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

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

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

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::IfcMaterialLayer] = new IfcEntityDescriptor(Type::IfcMaterialLayer,0);

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

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

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

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

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

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

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

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

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

current->add("DirectionSense",false,IfcUtil::Argument_ENUMERATION,Type::IfcDirectionSenseEnum);

current->add("OffsetFromReferenceLine",false,IfcUtil::Argument_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::IfcMaterialProperties] = new IfcEntityDescriptor(Type::IfcMaterialProperties,0);

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

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::IfcMechanicalMaterialProperties] = new IfcEntityDescriptor(Type::IfcMechanicalMaterialProperties,entity_descriptor_map.find(Type::IfcMaterialProperties)->second);

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

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

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

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

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

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

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

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

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

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

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

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

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

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 = entity_descriptor_map[Type::IfcMonetaryUnit] = new IfcEntityDescriptor(Type::IfcMonetaryUnit,0);

current->add("Currency",false,IfcUtil::Argument_ENUMERATION,Type::IfcCurrencyEnum);

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);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

current->add("Id",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::IfcOrganizationRelationship] = new IfcEntityDescriptor(Type::IfcOrganizationRelationship,0);

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

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

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

current->add("RelatedOrganizations",false,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",false,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("Id",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::IfcPreDefinedItem] = new IfcEntityDescriptor(Type::IfcPreDefinedItem,0);

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

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

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

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

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::IfcProductsOfCombustionProperties] = new IfcEntityDescriptor(Type::IfcProductsOfCombustionProperties,entity_descriptor_map.find(Type::IfcMaterialProperties)->second);

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

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

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

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

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::IfcProfileProperties] = new IfcEntityDescriptor(Type::IfcProfileProperties,0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 = entity_descriptor_map[Type::IfcQuantityCount] = new IfcEntityDescriptor(Type::IfcQuantityCount,entity_descriptor_map.find(Type::IfcPhysicalSimpleQuantity)->second);

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

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 = entity_descriptor_map[Type::IfcQuantityTime] = new IfcEntityDescriptor(Type::IfcQuantityTime,entity_descriptor_map.find(Type::IfcPhysicalSimpleQuantity)->second);

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

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 = entity_descriptor_map[Type::IfcQuantityWeight] = new IfcEntityDescriptor(Type::IfcQuantityWeight,entity_descriptor_map.find(Type::IfcPhysicalSimpleQuantity)->second);

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

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

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

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

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

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

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

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

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

current->add("BarSurface",true,IfcUtil::Argument_ENUMERATION,Type::IfcReinforcingBarSurfaceEnum);

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

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

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

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

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

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

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::IfcRibPlateProfileProperties] = new IfcEntityDescriptor(Type::IfcRibPlateProfileProperties,entity_descriptor_map.find(Type::IfcProfileProperties)->second);

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

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

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

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

current->add("Direction",false,IfcUtil::Argument_ENUMERATION,Type::IfcRibPlateDirectionEnum);

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

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

current->add("OwnerHistory",false,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::IfcSectionProperties] = new IfcEntityDescriptor(Type::IfcSectionProperties,0);

current->add("SectionType",false,IfcUtil::Argument_ENUMERATION,Type::IfcSectionTypeEnum);

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

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

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

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

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

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

current->add("ReinforcementRole",false,IfcUtil::Argument_ENUMERATION,Type::IfcReinforcingBarRoleEnum);

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

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

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",false,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::IfcSimpleProperty] = new IfcEntityDescriptor(Type::IfcSimpleProperty,entity_descriptor_map.find(Type::IfcProperty)->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::IfcStructuralLoadStatic] = new IfcEntityDescriptor(Type::IfcStructuralLoadStatic,entity_descriptor_map.find(Type::IfcStructuralLoad)->second);

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

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

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

current->add("DeltaT_Z",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::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,0);

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,0);

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

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

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

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

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

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

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

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

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

current->add("TextureType",false,IfcUtil::Argument_ENUMERATION,Type::IfcSurfaceTextureEnum);

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

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

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

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

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

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

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

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

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

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 = 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 = entity_descriptor_map[Type::IfcTextStyleFontModel] = new IfcEntityDescriptor(Type::IfcTextStyleFontModel,entity_descriptor_map.find(Type::IfcPreDefinedTextFont)->second);

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

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

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

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

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

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

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

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

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

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::IfcTextStyleWithBoxCharacteristics] = new IfcEntityDescriptor(Type::IfcTextStyleWithBoxCharacteristics,0);

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

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

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

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

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

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

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",false,IfcUtil::Argument_ENTITY_LIST);

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

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

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

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

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

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

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

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

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

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_ENTITY);

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

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::IfcTimeSeriesReferenceRelationship] = new IfcEntityDescriptor(Type::IfcTimeSeriesReferenceRelationship,0);

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

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

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::IfcVertexBasedTextureMap] = new IfcEntityDescriptor(Type::IfcVertexBasedTextureMap,0);

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

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

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::IfcWaterProperties] = new IfcEntityDescriptor(Type::IfcWaterProperties,entity_descriptor_map.find(Type::IfcMaterialProperties)->second);

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

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

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

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

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

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

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

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

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

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

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

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->add("RasterCode",false,IfcUtil::Argument_BOOL);

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::IfcClassificationReference] = new IfcEntityDescriptor(Type::IfcClassificationReference,entity_descriptor_map.find(Type::IfcExternalReference)->second);

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

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

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

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

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

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

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

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

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::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 = 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::IfcDimensionCalloutRelationship] = new IfcEntityDescriptor(Type::IfcDimensionCalloutRelationship,entity_descriptor_map.find(Type::IfcDraughtingCalloutRelationship)->second);

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

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

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

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::IfcExtendedMaterialProperties] = new IfcEntityDescriptor(Type::IfcExtendedMaterialProperties,entity_descriptor_map.find(Type::IfcMaterialProperties)->second);

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

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

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

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 = entity_descriptor_map[Type::IfcFuelProperties] = new IfcEntityDescriptor(Type::IfcFuelProperties,entity_descriptor_map.find(Type::IfcMaterialProperties)->second);

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

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

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

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

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

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

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

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

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

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

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

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