From 266d6f4c97e1bd1bbb1c49ed4a8809429110aa0b Mon Sep 17 00:00:00 2001 From: aothms Date: Thu, 13 Aug 2015 14:26:14 +0200 Subject: [PATCH 1/4] Cache the output of the parsed express schema as a Python pickle stream for speedier code generation --- src/ifcexpressparser/bootstrap.py | 38 ++++++++++++++++++++----------- 1 file changed, 25 insertions(+), 13 deletions(-) diff --git a/src/ifcexpressparser/bootstrap.py b/src/ifcexpressparser/bootstrap.py index bb9e4a58e6..c994bd4515 100644 --- a/src/ifcexpressparser/bootstrap.py +++ b/src/ifcexpressparser/bootstrap.py @@ -158,30 +158,42 @@ for id in to_emit: stmt = "Suppress%s" % stmt statements.append("%s << %s" % (id, stmt)) -print ("""import sys -from pyparsing import * -from nodes import * +print ("""import os +import sys +import pickle -%s +cache_file = sys.argv[1] + ".cache.dat" +if os.path.exists(cache_file): + with open(cache_file, "rb") as f: + mapping = pickle.load(f) +else: + from pyparsing import * + from nodes import * + + import schema + import mapping + + %s + + syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))")) + ast = syntax.parseFile(sys.argv[1]) + schema = schema.Schema(ast) + mapping = mapping.Mapping(schema) -import schema -import mapping + with open(cache_file, "wb") as f: + pickle.dump(mapping, f, protocol=0) import header import enum_header import implementation import latebound_header import latebound_implementation - -syntax.ignore("--" + restOfLine) -syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))")) -ast = syntax.parseFile(sys.argv[1]) -schema = schema.Schema(ast) -mapping = mapping.Mapping(schema) +import schema_class header.Header(mapping).emit() enum_header.EnumHeader(mapping).emit() implementation.Implementation(mapping).emit() latebound_header.LateBoundHeader(mapping).emit() latebound_implementation.LateBoundImplementation(mapping).emit() -"""%('\n'.join(statements))) +schema_class.SchemaClass(mapping).emit() +"""%('\n '.join(statements))) From 822fa91f4d5328ff2d10088a2d1e7feafc7bbbf5 Mon Sep 17 00:00:00 2001 From: aothms Date: Thu, 13 Aug 2015 14:28:50 +0200 Subject: [PATCH 2/4] Work on a C++ representation of the parsed EXPRESS schema --- src/ifcexpressparser/schema_class.py | 121 + src/ifcparse/Ifc2x3-schema.cpp | 8623 ++++++++++++++++++++++++++ src/ifcparse/IfcSchema.h | 245 + 3 files changed, 8989 insertions(+) create mode 100644 src/ifcexpressparser/schema_class.py create mode 100644 src/ifcparse/Ifc2x3-schema.cpp create mode 100644 src/ifcparse/IfcSchema.h diff --git a/src/ifcexpressparser/schema_class.py b/src/ifcexpressparser/schema_class.py new file mode 100644 index 0000000000..8cb391e1ed --- /dev/null +++ b/src/ifcexpressparser/schema_class.py @@ -0,0 +1,121 @@ +############################################################################### +# # +# 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 . # +# # +############################################################################### + +import operator + +import nodes +import templates + +class SchemaClass: + def __init__(self, mapping): + + class UnmetDependenciesException(Exception): pass + + def get_declared_type(type, emitted_names=None): + if isinstance(type, nodes.AggregationType): + aggr_type = type.aggregate_type + make_bound = lambda b: -1 if b == '?' else int(b) + bound1, bound2 = map(make_bound, (type.bounds.lower, type.bounds.upper)) + decl_type = get_declared_type(type.type) + return "new aggregation_type(aggregation_type::%(aggr_type)s_type, %(bound1)d, %(bound2)d, %(decl_type)s)" % locals() + elif isinstance(type, nodes.BinaryType): + return "new simple_type(simple_type::binary_type)" + elif isinstance(type, str): + if mapping.schema.is_type(type) or mapping.schema.is_entity(type): + if emitted_names is None or type in emitted_types: + return "new named_type(%s_type)" % type + else: + raise UnmetDependenciesException(type) + else: + return "new simple_type(simple_type::%s_type)" % type + + self.schema_name = mapping.schema.name.capitalize() + + statements = ['','#include "../ifcparse/IfcSchema.h"','','void populate() {'] + + emitted_types = set() + while len(emitted_types) < len(mapping.schema.simpletypes): + for name, type in mapping.schema.simpletypes.items(): + if name in emitted_types: continue + + try: + declared_type = get_declared_type(type, emitted_types) + except UnmetDependenciesException: + continue + + statements.append(' declaration* %(name)s_type = new type_declaration("%(name)s", %(declared_type)s);' % locals()) + emitted_types.add(name) + + for name, enum in mapping.schema.enumerations.items(): + statements.append(' declaration* %(name)s_type;' % locals()) + statements.append(' {') + statements.append(' std::vector items; items.reserve(%d);' % len(enum.values)) + statements.extend(map(lambda v: ' items.push_back("%s");' % v, sorted(enum.values))) + statements.append(' %(name)s_type = new enumeration_type("%(name)s", items);' % locals()) + statements.append(' }') + + emitted_entities = set() + while len(emitted_entities) < len(mapping.schema.entities): + for name, type in mapping.schema.entities.items(): + if name in emitted_entities: continue + if len(type.supertypes) == 0 or set(type.supertypes) < emitted_entities: + supertype = '0' if len(type.supertypes) == 0 else '%s_type' % type.supertypes[0] + statements.append(' entity* %(name)s_type = new entity("%(name)s", %(supertype)s);' % locals()) + emitted_entities.add(name) + + emmited = emitted_types | emitted_entities | set(mapping.schema.enumerations.keys()) + + emitted_selects = set() + while len(emitted_selects) < len(mapping.schema.selects): + for name, type in mapping.schema.selects.items(): + if name in emitted_selects: continue + if set(type.values) < emmited: + statements.append(' declaration* %(name)s_type;' % locals()) + statements.append(' {') + statements.append(' std::vector items; items.reserve(%d);' % len(type.values)) + statements.extend(map(lambda v: ' items.push_back(%s_type);' % v, sorted(type.values))) + statements.append(' %(name)s_type = new select_type("%(name)s", items);' % locals()) + statements.append(' }') + emitted_selects.add(name) + emmited.add(name) + + for name, type in mapping.schema.entities.items(): + derived = set(mapping.derived_in_supertype(type)) + attribute_names = list(map(operator.attrgetter('name'), mapping.arguments(type))) + + statements.append(' {') + statements.append(' std::vector attributes; attributes.reserve(%d);' % len(type.attributes)) + for attr in type.attributes: + attr_name, optional = attr.name, str(attr.optional).lower() + decl_type = get_declared_type(attr.type) + statements.append(' attributes.push_back(new entity::attribute("%(attr_name)s", %(decl_type)s, %(optional)s));' % locals()) + statements.append(' std::vector derived; derived.reserve(%d);' % len(attribute_names)) + statements.append(' ' + " ".join(map(lambda b: 'derived.push_back(%s);' % str(b in derived).lower(), attribute_names))) + statements.append(' %(name)s_type->set_attributes(attributes, derived);' % locals()) + statements.append(' }') + + statements.extend(('}','','')) + self.str = "\n".join(statements) + def __repr__(self): + return self.str + def emit(self): + f = open('%s-schema.cpp'%self.schema_name, 'w', encoding='utf-8') + f.write(str(self)) + f.close() + diff --git a/src/ifcparse/Ifc2x3-schema.cpp b/src/ifcparse/Ifc2x3-schema.cpp new file mode 100644 index 0000000000..9dcc7d315c --- /dev/null +++ b/src/ifcparse/Ifc2x3-schema.cpp @@ -0,0 +1,8623 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +/******************************************************************************** + * * + * This file has been generated from IFC2X3_TC1.exp. Do not make modifications * + * but instead modify the python script that has been used to generate this. * + * * + ********************************************************************************/ + +#ifndef USE_IFC4 + +#include "../ifcparse/IfcSchema.h" + +void populate() { + declaration* IfcAbsorbedDoseMeasure_type = new type_declaration("IfcAbsorbedDoseMeasure", new simple_type(simple_type::real_type)); + declaration* IfcAccelerationMeasure_type = new type_declaration("IfcAccelerationMeasure", new simple_type(simple_type::real_type)); + declaration* IfcAmountOfSubstanceMeasure_type = new type_declaration("IfcAmountOfSubstanceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcAngularVelocityMeasure_type = new type_declaration("IfcAngularVelocityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcAreaMeasure_type = new type_declaration("IfcAreaMeasure", new simple_type(simple_type::real_type)); + declaration* IfcBoolean_type = new type_declaration("IfcBoolean", new simple_type(simple_type::boolean_type)); + declaration* IfcComplexNumber_type = new type_declaration("IfcComplexNumber", new aggregation_type(aggregation_type::array_type, 1, 2, new simple_type(simple_type::real_type))); + declaration* IfcCompoundPlaneAngleMeasure_type = new type_declaration("IfcCompoundPlaneAngleMeasure", new aggregation_type(aggregation_type::list_type, 3, 4, new simple_type(simple_type::integer_type))); + declaration* IfcContextDependentMeasure_type = new type_declaration("IfcContextDependentMeasure", new simple_type(simple_type::real_type)); + declaration* IfcCountMeasure_type = new type_declaration("IfcCountMeasure", new simple_type(simple_type::number_type)); + declaration* IfcCurvatureMeasure_type = new type_declaration("IfcCurvatureMeasure", new simple_type(simple_type::real_type)); + declaration* IfcDayInMonthNumber_type = new type_declaration("IfcDayInMonthNumber", new simple_type(simple_type::integer_type)); + declaration* IfcDaylightSavingHour_type = new type_declaration("IfcDaylightSavingHour", new simple_type(simple_type::integer_type)); + declaration* IfcDescriptiveMeasure_type = new type_declaration("IfcDescriptiveMeasure", new simple_type(simple_type::string_type)); + declaration* IfcDimensionCount_type = new type_declaration("IfcDimensionCount", new simple_type(simple_type::integer_type)); + declaration* IfcDoseEquivalentMeasure_type = new type_declaration("IfcDoseEquivalentMeasure", new simple_type(simple_type::real_type)); + declaration* IfcDynamicViscosityMeasure_type = new type_declaration("IfcDynamicViscosityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcElectricCapacitanceMeasure_type = new type_declaration("IfcElectricCapacitanceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcElectricChargeMeasure_type = new type_declaration("IfcElectricChargeMeasure", new simple_type(simple_type::real_type)); + declaration* IfcElectricConductanceMeasure_type = new type_declaration("IfcElectricConductanceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcElectricCurrentMeasure_type = new type_declaration("IfcElectricCurrentMeasure", new simple_type(simple_type::real_type)); + declaration* IfcElectricResistanceMeasure_type = new type_declaration("IfcElectricResistanceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcElectricVoltageMeasure_type = new type_declaration("IfcElectricVoltageMeasure", new simple_type(simple_type::real_type)); + declaration* IfcEnergyMeasure_type = new type_declaration("IfcEnergyMeasure", new simple_type(simple_type::real_type)); + declaration* IfcFontStyle_type = new type_declaration("IfcFontStyle", new simple_type(simple_type::string_type)); + declaration* IfcFontVariant_type = new type_declaration("IfcFontVariant", new simple_type(simple_type::string_type)); + declaration* IfcFontWeight_type = new type_declaration("IfcFontWeight", new simple_type(simple_type::string_type)); + declaration* IfcForceMeasure_type = new type_declaration("IfcForceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcFrequencyMeasure_type = new type_declaration("IfcFrequencyMeasure", new simple_type(simple_type::real_type)); + declaration* IfcGloballyUniqueId_type = new type_declaration("IfcGloballyUniqueId", new simple_type(simple_type::string_type)); + declaration* IfcHeatFluxDensityMeasure_type = new type_declaration("IfcHeatFluxDensityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcHeatingValueMeasure_type = new type_declaration("IfcHeatingValueMeasure", new simple_type(simple_type::real_type)); + declaration* IfcHourInDay_type = new type_declaration("IfcHourInDay", new simple_type(simple_type::integer_type)); + declaration* IfcIdentifier_type = new type_declaration("IfcIdentifier", new simple_type(simple_type::string_type)); + declaration* IfcIlluminanceMeasure_type = new type_declaration("IfcIlluminanceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcInductanceMeasure_type = new type_declaration("IfcInductanceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcInteger_type = new type_declaration("IfcInteger", new simple_type(simple_type::integer_type)); + declaration* IfcIntegerCountRateMeasure_type = new type_declaration("IfcIntegerCountRateMeasure", new simple_type(simple_type::integer_type)); + declaration* IfcIonConcentrationMeasure_type = new type_declaration("IfcIonConcentrationMeasure", new simple_type(simple_type::real_type)); + declaration* IfcIsothermalMoistureCapacityMeasure_type = new type_declaration("IfcIsothermalMoistureCapacityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcKinematicViscosityMeasure_type = new type_declaration("IfcKinematicViscosityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcLabel_type = new type_declaration("IfcLabel", new simple_type(simple_type::string_type)); + declaration* IfcLengthMeasure_type = new type_declaration("IfcLengthMeasure", new simple_type(simple_type::real_type)); + declaration* IfcLinearForceMeasure_type = new type_declaration("IfcLinearForceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcLinearMomentMeasure_type = new type_declaration("IfcLinearMomentMeasure", new simple_type(simple_type::real_type)); + declaration* IfcLinearStiffnessMeasure_type = new type_declaration("IfcLinearStiffnessMeasure", new simple_type(simple_type::real_type)); + declaration* IfcLinearVelocityMeasure_type = new type_declaration("IfcLinearVelocityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcLogical_type = new type_declaration("IfcLogical", new simple_type(simple_type::logical_type)); + declaration* IfcLuminousFluxMeasure_type = new type_declaration("IfcLuminousFluxMeasure", new simple_type(simple_type::real_type)); + declaration* IfcLuminousIntensityDistributionMeasure_type = new type_declaration("IfcLuminousIntensityDistributionMeasure", new simple_type(simple_type::real_type)); + declaration* IfcLuminousIntensityMeasure_type = new type_declaration("IfcLuminousIntensityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMagneticFluxDensityMeasure_type = new type_declaration("IfcMagneticFluxDensityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMagneticFluxMeasure_type = new type_declaration("IfcMagneticFluxMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMassDensityMeasure_type = new type_declaration("IfcMassDensityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMassFlowRateMeasure_type = new type_declaration("IfcMassFlowRateMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMassMeasure_type = new type_declaration("IfcMassMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMassPerLengthMeasure_type = new type_declaration("IfcMassPerLengthMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMinuteInHour_type = new type_declaration("IfcMinuteInHour", new simple_type(simple_type::integer_type)); + declaration* IfcModulusOfElasticityMeasure_type = new type_declaration("IfcModulusOfElasticityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcModulusOfLinearSubgradeReactionMeasure_type = new type_declaration("IfcModulusOfLinearSubgradeReactionMeasure", new simple_type(simple_type::real_type)); + declaration* IfcModulusOfRotationalSubgradeReactionMeasure_type = new type_declaration("IfcModulusOfRotationalSubgradeReactionMeasure", new simple_type(simple_type::real_type)); + declaration* IfcModulusOfSubgradeReactionMeasure_type = new type_declaration("IfcModulusOfSubgradeReactionMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMoistureDiffusivityMeasure_type = new type_declaration("IfcMoistureDiffusivityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMolecularWeightMeasure_type = new type_declaration("IfcMolecularWeightMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMomentOfInertiaMeasure_type = new type_declaration("IfcMomentOfInertiaMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMonetaryMeasure_type = new type_declaration("IfcMonetaryMeasure", new simple_type(simple_type::real_type)); + declaration* IfcMonthInYearNumber_type = new type_declaration("IfcMonthInYearNumber", new simple_type(simple_type::integer_type)); + declaration* IfcNumericMeasure_type = new type_declaration("IfcNumericMeasure", new simple_type(simple_type::number_type)); + declaration* IfcPHMeasure_type = new type_declaration("IfcPHMeasure", new simple_type(simple_type::real_type)); + declaration* IfcParameterValue_type = new type_declaration("IfcParameterValue", new simple_type(simple_type::real_type)); + declaration* IfcPlanarForceMeasure_type = new type_declaration("IfcPlanarForceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcPlaneAngleMeasure_type = new type_declaration("IfcPlaneAngleMeasure", new simple_type(simple_type::real_type)); + declaration* IfcPositiveLengthMeasure_type = new type_declaration("IfcPositiveLengthMeasure", new named_type(IfcLengthMeasure_type)); + declaration* IfcPositivePlaneAngleMeasure_type = new type_declaration("IfcPositivePlaneAngleMeasure", new named_type(IfcPlaneAngleMeasure_type)); + declaration* IfcPowerMeasure_type = new type_declaration("IfcPowerMeasure", new simple_type(simple_type::real_type)); + declaration* IfcPresentableText_type = new type_declaration("IfcPresentableText", new simple_type(simple_type::string_type)); + declaration* IfcPressureMeasure_type = new type_declaration("IfcPressureMeasure", new simple_type(simple_type::real_type)); + declaration* IfcRadioActivityMeasure_type = new type_declaration("IfcRadioActivityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcRatioMeasure_type = new type_declaration("IfcRatioMeasure", new simple_type(simple_type::real_type)); + declaration* IfcReal_type = new type_declaration("IfcReal", new simple_type(simple_type::real_type)); + declaration* IfcRotationalFrequencyMeasure_type = new type_declaration("IfcRotationalFrequencyMeasure", new simple_type(simple_type::real_type)); + declaration* IfcRotationalMassMeasure_type = new type_declaration("IfcRotationalMassMeasure", new simple_type(simple_type::real_type)); + declaration* IfcRotationalStiffnessMeasure_type = new type_declaration("IfcRotationalStiffnessMeasure", new simple_type(simple_type::real_type)); + declaration* IfcSecondInMinute_type = new type_declaration("IfcSecondInMinute", new simple_type(simple_type::real_type)); + declaration* IfcSectionModulusMeasure_type = new type_declaration("IfcSectionModulusMeasure", new simple_type(simple_type::real_type)); + declaration* IfcSectionalAreaIntegralMeasure_type = new type_declaration("IfcSectionalAreaIntegralMeasure", new simple_type(simple_type::real_type)); + declaration* IfcShearModulusMeasure_type = new type_declaration("IfcShearModulusMeasure", new simple_type(simple_type::real_type)); + declaration* IfcSolidAngleMeasure_type = new type_declaration("IfcSolidAngleMeasure", new simple_type(simple_type::real_type)); + declaration* IfcSoundPowerMeasure_type = new type_declaration("IfcSoundPowerMeasure", new simple_type(simple_type::real_type)); + declaration* IfcSoundPressureMeasure_type = new type_declaration("IfcSoundPressureMeasure", new simple_type(simple_type::real_type)); + declaration* IfcSpecificHeatCapacityMeasure_type = new type_declaration("IfcSpecificHeatCapacityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcSpecularExponent_type = new type_declaration("IfcSpecularExponent", new simple_type(simple_type::real_type)); + declaration* IfcSpecularRoughness_type = new type_declaration("IfcSpecularRoughness", new simple_type(simple_type::real_type)); + declaration* IfcTemperatureGradientMeasure_type = new type_declaration("IfcTemperatureGradientMeasure", new simple_type(simple_type::real_type)); + declaration* IfcText_type = new type_declaration("IfcText", new simple_type(simple_type::string_type)); + declaration* IfcTextAlignment_type = new type_declaration("IfcTextAlignment", new simple_type(simple_type::string_type)); + declaration* IfcTextDecoration_type = new type_declaration("IfcTextDecoration", new simple_type(simple_type::string_type)); + declaration* IfcTextFontName_type = new type_declaration("IfcTextFontName", new simple_type(simple_type::string_type)); + declaration* IfcTextTransformation_type = new type_declaration("IfcTextTransformation", new simple_type(simple_type::string_type)); + declaration* IfcThermalAdmittanceMeasure_type = new type_declaration("IfcThermalAdmittanceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcThermalConductivityMeasure_type = new type_declaration("IfcThermalConductivityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcThermalExpansionCoefficientMeasure_type = new type_declaration("IfcThermalExpansionCoefficientMeasure", new simple_type(simple_type::real_type)); + declaration* IfcThermalResistanceMeasure_type = new type_declaration("IfcThermalResistanceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcThermalTransmittanceMeasure_type = new type_declaration("IfcThermalTransmittanceMeasure", new simple_type(simple_type::real_type)); + declaration* IfcThermodynamicTemperatureMeasure_type = new type_declaration("IfcThermodynamicTemperatureMeasure", new simple_type(simple_type::real_type)); + declaration* IfcTimeMeasure_type = new type_declaration("IfcTimeMeasure", new simple_type(simple_type::real_type)); + declaration* IfcTimeStamp_type = new type_declaration("IfcTimeStamp", new simple_type(simple_type::integer_type)); + declaration* IfcTorqueMeasure_type = new type_declaration("IfcTorqueMeasure", new simple_type(simple_type::real_type)); + declaration* IfcVaporPermeabilityMeasure_type = new type_declaration("IfcVaporPermeabilityMeasure", new simple_type(simple_type::real_type)); + declaration* IfcVolumeMeasure_type = new type_declaration("IfcVolumeMeasure", new simple_type(simple_type::real_type)); + declaration* IfcVolumetricFlowRateMeasure_type = new type_declaration("IfcVolumetricFlowRateMeasure", new simple_type(simple_type::real_type)); + declaration* IfcWarpingConstantMeasure_type = new type_declaration("IfcWarpingConstantMeasure", new simple_type(simple_type::real_type)); + declaration* IfcWarpingMomentMeasure_type = new type_declaration("IfcWarpingMomentMeasure", new simple_type(simple_type::real_type)); + declaration* IfcYearNumber_type = new type_declaration("IfcYearNumber", new simple_type(simple_type::integer_type)); + declaration* IfcBoxAlignment_type = new type_declaration("IfcBoxAlignment", new named_type(IfcLabel_type)); + declaration* IfcNormalisedRatioMeasure_type = new type_declaration("IfcNormalisedRatioMeasure", new named_type(IfcRatioMeasure_type)); + declaration* IfcPositiveRatioMeasure_type = new type_declaration("IfcPositiveRatioMeasure", new named_type(IfcRatioMeasure_type)); + declaration* IfcActionSourceTypeEnum_type; + { + std::vector items; items.reserve(27); + items.push_back("BRAKES"); + items.push_back("BUOYANCY"); + items.push_back("COMPLETION_G1"); + items.push_back("CREEP"); + items.push_back("CURRENT"); + items.push_back("DEAD_LOAD_G"); + items.push_back("EARTHQUAKE_E"); + items.push_back("ERECTION"); + items.push_back("FIRE"); + items.push_back("ICE"); + items.push_back("IMPACT"); + items.push_back("IMPULSE"); + items.push_back("LACK_OF_FIT"); + items.push_back("LIVE_LOAD_Q"); + items.push_back("NOTDEFINED"); + items.push_back("PRESTRESSING_P"); + items.push_back("PROPPING"); + items.push_back("RAIN"); + items.push_back("SETTLEMENT_U"); + items.push_back("SHRINKAGE"); + items.push_back("SNOW_S"); + items.push_back("SYSTEM_IMPERFECTION"); + items.push_back("TEMPERATURE_T"); + items.push_back("TRANSPORT"); + items.push_back("USERDEFINED"); + items.push_back("WAVE"); + items.push_back("WIND_W"); + IfcActionSourceTypeEnum_type = new enumeration_type("IfcActionSourceTypeEnum", items); + } + declaration* IfcActionTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("EXTRAORDINARY_A"); + items.push_back("NOTDEFINED"); + items.push_back("PERMANENT_G"); + items.push_back("USERDEFINED"); + items.push_back("VARIABLE_Q"); + IfcActionTypeEnum_type = new enumeration_type("IfcActionTypeEnum", items); + } + declaration* IfcActuatorTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("ELECTRICACTUATOR"); + items.push_back("HANDOPERATEDACTUATOR"); + items.push_back("HYDRAULICACTUATOR"); + items.push_back("NOTDEFINED"); + items.push_back("PNEUMATICACTUATOR"); + items.push_back("THERMOSTATICACTUATOR"); + items.push_back("USERDEFINED"); + IfcActuatorTypeEnum_type = new enumeration_type("IfcActuatorTypeEnum", items); + } + declaration* IfcAddressTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("DISTRIBUTIONPOINT"); + items.push_back("HOME"); + items.push_back("OFFICE"); + items.push_back("SITE"); + items.push_back("USERDEFINED"); + IfcAddressTypeEnum_type = new enumeration_type("IfcAddressTypeEnum", items); + } + declaration* IfcAheadOrBehind_type; + { + std::vector items; items.reserve(2); + items.push_back("AHEAD"); + items.push_back("BEHIND"); + IfcAheadOrBehind_type = new enumeration_type("IfcAheadOrBehind", items); + } + declaration* IfcAirTerminalBoxTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("CONSTANTFLOW"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + items.push_back("VARIABLEFLOWPRESSUREDEPENDANT"); + items.push_back("VARIABLEFLOWPRESSUREINDEPENDANT"); + IfcAirTerminalBoxTypeEnum_type = new enumeration_type("IfcAirTerminalBoxTypeEnum", items); + } + declaration* IfcAirTerminalTypeEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("DIFFUSER"); + items.push_back("EYEBALL"); + items.push_back("GRILLE"); + items.push_back("IRIS"); + items.push_back("LINEARDIFFUSER"); + items.push_back("LINEARGRILLE"); + items.push_back("NOTDEFINED"); + items.push_back("REGISTER"); + items.push_back("USERDEFINED"); + IfcAirTerminalTypeEnum_type = new enumeration_type("IfcAirTerminalTypeEnum", items); + } + declaration* IfcAirToAirHeatRecoveryTypeEnum_type; + { + std::vector items; items.reserve(11); + items.push_back("FIXEDPLATECOUNTERFLOWEXCHANGER"); + items.push_back("FIXEDPLATECROSSFLOWEXCHANGER"); + items.push_back("FIXEDPLATEPARALLELFLOWEXCHANGER"); + items.push_back("HEATPIPE"); + items.push_back("NOTDEFINED"); + items.push_back("ROTARYWHEEL"); + items.push_back("RUNAROUNDCOILLOOP"); + items.push_back("THERMOSIPHONCOILTYPEHEATEXCHANGERS"); + items.push_back("THERMOSIPHONSEALEDTUBEHEATEXCHANGERS"); + items.push_back("TWINTOWERENTHALPYRECOVERYLOOPS"); + items.push_back("USERDEFINED"); + IfcAirToAirHeatRecoveryTypeEnum_type = new enumeration_type("IfcAirToAirHeatRecoveryTypeEnum", items); + } + declaration* IfcAlarmTypeEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("BELL"); + items.push_back("BREAKGLASSBUTTON"); + items.push_back("LIGHT"); + items.push_back("MANUALPULLBOX"); + items.push_back("NOTDEFINED"); + items.push_back("SIREN"); + items.push_back("USERDEFINED"); + items.push_back("WHISTLE"); + IfcAlarmTypeEnum_type = new enumeration_type("IfcAlarmTypeEnum", items); + } + declaration* IfcAnalysisModelTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("IN_PLANE_LOADING_2D"); + items.push_back("LOADING_3D"); + items.push_back("NOTDEFINED"); + items.push_back("OUT_PLANE_LOADING_2D"); + items.push_back("USERDEFINED"); + IfcAnalysisModelTypeEnum_type = new enumeration_type("IfcAnalysisModelTypeEnum", items); + } + declaration* IfcAnalysisTheoryTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("FIRST_ORDER_THEORY"); + items.push_back("FULL_NONLINEAR_THEORY"); + items.push_back("NOTDEFINED"); + items.push_back("SECOND_ORDER_THEORY"); + items.push_back("THIRD_ORDER_THEORY"); + items.push_back("USERDEFINED"); + IfcAnalysisTheoryTypeEnum_type = new enumeration_type("IfcAnalysisTheoryTypeEnum", items); + } + declaration* IfcArithmeticOperatorEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("ADD"); + items.push_back("DIVIDE"); + items.push_back("MULTIPLY"); + items.push_back("SUBTRACT"); + IfcArithmeticOperatorEnum_type = new enumeration_type("IfcArithmeticOperatorEnum", items); + } + declaration* IfcAssemblyPlaceEnum_type; + { + std::vector items; items.reserve(3); + items.push_back("FACTORY"); + items.push_back("NOTDEFINED"); + items.push_back("SITE"); + IfcAssemblyPlaceEnum_type = new enumeration_type("IfcAssemblyPlaceEnum", items); + } + declaration* IfcBSplineCurveForm_type; + { + std::vector items; items.reserve(6); + items.push_back("CIRCULAR_ARC"); + items.push_back("ELLIPTIC_ARC"); + items.push_back("HYPERBOLIC_ARC"); + items.push_back("PARABOLIC_ARC"); + items.push_back("POLYLINE_FORM"); + items.push_back("UNSPECIFIED"); + IfcBSplineCurveForm_type = new enumeration_type("IfcBSplineCurveForm", items); + } + declaration* IfcBeamTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("BEAM"); + items.push_back("JOIST"); + items.push_back("LINTEL"); + items.push_back("NOTDEFINED"); + items.push_back("T_BEAM"); + items.push_back("USERDEFINED"); + IfcBeamTypeEnum_type = new enumeration_type("IfcBeamTypeEnum", items); + } + declaration* IfcBenchmarkEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("EQUALTO"); + items.push_back("GREATERTHAN"); + items.push_back("GREATERTHANOREQUALTO"); + items.push_back("LESSTHAN"); + items.push_back("LESSTHANOREQUALTO"); + items.push_back("NOTEQUALTO"); + IfcBenchmarkEnum_type = new enumeration_type("IfcBenchmarkEnum", items); + } + declaration* IfcBoilerTypeEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("NOTDEFINED"); + items.push_back("STEAM"); + items.push_back("USERDEFINED"); + items.push_back("WATER"); + IfcBoilerTypeEnum_type = new enumeration_type("IfcBoilerTypeEnum", items); + } + declaration* IfcBooleanOperator_type; + { + std::vector items; items.reserve(3); + items.push_back("DIFFERENCE"); + items.push_back("INTERSECTION"); + items.push_back("UNION"); + IfcBooleanOperator_type = new enumeration_type("IfcBooleanOperator", items); + } + declaration* IfcBuildingElementProxyTypeEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcBuildingElementProxyTypeEnum_type = new enumeration_type("IfcBuildingElementProxyTypeEnum", items); + } + declaration* IfcCableCarrierFittingTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("BEND"); + items.push_back("CROSS"); + items.push_back("NOTDEFINED"); + items.push_back("REDUCER"); + items.push_back("TEE"); + items.push_back("USERDEFINED"); + IfcCableCarrierFittingTypeEnum_type = new enumeration_type("IfcCableCarrierFittingTypeEnum", items); + } + declaration* IfcCableCarrierSegmentTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("CABLELADDERSEGMENT"); + items.push_back("CABLETRAYSEGMENT"); + items.push_back("CABLETRUNKINGSEGMENT"); + items.push_back("CONDUITSEGMENT"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcCableCarrierSegmentTypeEnum_type = new enumeration_type("IfcCableCarrierSegmentTypeEnum", items); + } + declaration* IfcCableSegmentTypeEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("CABLESEGMENT"); + items.push_back("CONDUCTORSEGMENT"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcCableSegmentTypeEnum_type = new enumeration_type("IfcCableSegmentTypeEnum", items); + } + declaration* IfcChangeActionEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("ADDED"); + items.push_back("DELETED"); + items.push_back("MODIFIED"); + items.push_back("MODIFIEDADDED"); + items.push_back("MODIFIEDDELETED"); + items.push_back("NOCHANGE"); + IfcChangeActionEnum_type = new enumeration_type("IfcChangeActionEnum", items); + } + declaration* IfcChillerTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("AIRCOOLED"); + items.push_back("HEATRECOVERY"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + items.push_back("WATERCOOLED"); + IfcChillerTypeEnum_type = new enumeration_type("IfcChillerTypeEnum", items); + } + declaration* IfcCoilTypeEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("DXCOOLINGCOIL"); + items.push_back("ELECTRICHEATINGCOIL"); + items.push_back("GASHEATINGCOIL"); + items.push_back("NOTDEFINED"); + items.push_back("STEAMHEATINGCOIL"); + items.push_back("USERDEFINED"); + items.push_back("WATERCOOLINGCOIL"); + items.push_back("WATERHEATINGCOIL"); + IfcCoilTypeEnum_type = new enumeration_type("IfcCoilTypeEnum", items); + } + declaration* IfcColumnTypeEnum_type; + { + std::vector items; items.reserve(3); + items.push_back("COLUMN"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcColumnTypeEnum_type = new enumeration_type("IfcColumnTypeEnum", items); + } + declaration* IfcCompressorTypeEnum_type; + { + std::vector items; items.reserve(17); + items.push_back("BOOSTER"); + items.push_back("DYNAMIC"); + items.push_back("HERMETIC"); + items.push_back("NOTDEFINED"); + items.push_back("OPENTYPE"); + items.push_back("RECIPROCATING"); + items.push_back("ROLLINGPISTON"); + items.push_back("ROTARY"); + items.push_back("ROTARYVANE"); + items.push_back("SCROLL"); + items.push_back("SEMIHERMETIC"); + items.push_back("SINGLESCREW"); + items.push_back("SINGLESTAGE"); + items.push_back("TROCHOIDAL"); + items.push_back("TWINSCREW"); + items.push_back("USERDEFINED"); + items.push_back("WELDEDSHELLHERMETIC"); + IfcCompressorTypeEnum_type = new enumeration_type("IfcCompressorTypeEnum", items); + } + declaration* IfcCondenserTypeEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("AIRCOOLED"); + items.push_back("EVAPORATIVECOOLED"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + items.push_back("WATERCOOLEDBRAZEDPLATE"); + items.push_back("WATERCOOLEDSHELLCOIL"); + items.push_back("WATERCOOLEDSHELLTUBE"); + items.push_back("WATERCOOLEDTUBEINTUBE"); + IfcCondenserTypeEnum_type = new enumeration_type("IfcCondenserTypeEnum", items); + } + declaration* IfcConnectionTypeEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("ATEND"); + items.push_back("ATPATH"); + items.push_back("ATSTART"); + items.push_back("NOTDEFINED"); + IfcConnectionTypeEnum_type = new enumeration_type("IfcConnectionTypeEnum", items); + } + declaration* IfcConstraintEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("ADVISORY"); + items.push_back("HARD"); + items.push_back("NOTDEFINED"); + items.push_back("SOFT"); + items.push_back("USERDEFINED"); + IfcConstraintEnum_type = new enumeration_type("IfcConstraintEnum", items); + } + declaration* IfcControllerTypeEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("FLOATING"); + items.push_back("NOTDEFINED"); + items.push_back("PROPORTIONAL"); + items.push_back("PROPORTIONALINTEGRAL"); + items.push_back("PROPORTIONALINTEGRALDERIVATIVE"); + items.push_back("TIMEDTWOPOSITION"); + items.push_back("TWOPOSITION"); + items.push_back("USERDEFINED"); + IfcControllerTypeEnum_type = new enumeration_type("IfcControllerTypeEnum", items); + } + declaration* IfcCooledBeamTypeEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("ACTIVE"); + items.push_back("NOTDEFINED"); + items.push_back("PASSIVE"); + items.push_back("USERDEFINED"); + IfcCooledBeamTypeEnum_type = new enumeration_type("IfcCooledBeamTypeEnum", items); + } + declaration* IfcCoolingTowerTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("MECHANICALFORCEDDRAFT"); + items.push_back("MECHANICALINDUCEDDRAFT"); + items.push_back("NATURALDRAFT"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcCoolingTowerTypeEnum_type = new enumeration_type("IfcCoolingTowerTypeEnum", items); + } + declaration* IfcCostScheduleTypeEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("BUDGET"); + items.push_back("COSTPLAN"); + items.push_back("ESTIMATE"); + items.push_back("NOTDEFINED"); + items.push_back("PRICEDBILLOFQUANTITIES"); + items.push_back("SCHEDULEOFRATES"); + items.push_back("TENDER"); + items.push_back("UNPRICEDBILLOFQUANTITIES"); + items.push_back("USERDEFINED"); + IfcCostScheduleTypeEnum_type = new enumeration_type("IfcCostScheduleTypeEnum", items); + } + declaration* IfcCoveringTypeEnum_type; + { + std::vector items; items.reserve(10); + items.push_back("CEILING"); + items.push_back("CLADDING"); + items.push_back("FLOORING"); + items.push_back("INSULATION"); + items.push_back("MEMBRANE"); + items.push_back("NOTDEFINED"); + items.push_back("ROOFING"); + items.push_back("SLEEVING"); + items.push_back("USERDEFINED"); + items.push_back("WRAPPING"); + IfcCoveringTypeEnum_type = new enumeration_type("IfcCoveringTypeEnum", items); + } + declaration* IfcCurrencyEnum_type; + { + std::vector items; items.reserve(83); + items.push_back("AED"); + items.push_back("AES"); + items.push_back("ATS"); + items.push_back("AUD"); + items.push_back("BBD"); + items.push_back("BEG"); + items.push_back("BGL"); + items.push_back("BHD"); + items.push_back("BMD"); + items.push_back("BND"); + items.push_back("BRL"); + items.push_back("BSD"); + items.push_back("BWP"); + items.push_back("BZD"); + items.push_back("CAD"); + items.push_back("CBD"); + items.push_back("CHF"); + items.push_back("CLP"); + items.push_back("CNY"); + items.push_back("CYS"); + items.push_back("CZK"); + items.push_back("DDP"); + items.push_back("DEM"); + items.push_back("DKK"); + items.push_back("EGL"); + items.push_back("EST"); + items.push_back("EUR"); + items.push_back("FAK"); + items.push_back("FIM"); + items.push_back("FJD"); + items.push_back("FKP"); + items.push_back("FRF"); + items.push_back("GBP"); + items.push_back("GIP"); + items.push_back("GMD"); + items.push_back("GRX"); + items.push_back("HKD"); + items.push_back("HUF"); + items.push_back("ICK"); + items.push_back("IDR"); + items.push_back("ILS"); + items.push_back("INR"); + items.push_back("IRP"); + items.push_back("ITL"); + items.push_back("JMD"); + items.push_back("JOD"); + items.push_back("JPY"); + items.push_back("KES"); + items.push_back("KRW"); + items.push_back("KWD"); + items.push_back("KYD"); + items.push_back("LKR"); + items.push_back("LUF"); + items.push_back("MTL"); + items.push_back("MUR"); + items.push_back("MXN"); + items.push_back("MYR"); + items.push_back("NLG"); + items.push_back("NOK"); + items.push_back("NZD"); + items.push_back("OMR"); + items.push_back("PGK"); + items.push_back("PHP"); + items.push_back("PKR"); + items.push_back("PLN"); + items.push_back("PTN"); + items.push_back("QAR"); + items.push_back("RUR"); + items.push_back("SAR"); + items.push_back("SCR"); + items.push_back("SEK"); + items.push_back("SGD"); + items.push_back("SKP"); + items.push_back("THB"); + items.push_back("TRL"); + items.push_back("TTD"); + items.push_back("TWD"); + items.push_back("USD"); + items.push_back("VEB"); + items.push_back("VND"); + items.push_back("XEU"); + items.push_back("ZAR"); + items.push_back("ZWD"); + IfcCurrencyEnum_type = new enumeration_type("IfcCurrencyEnum", items); + } + declaration* IfcCurtainWallTypeEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcCurtainWallTypeEnum_type = new enumeration_type("IfcCurtainWallTypeEnum", items); + } + declaration* IfcDamperTypeEnum_type; + { + std::vector items; items.reserve(13); + items.push_back("BACKDRAFTDAMPER"); + items.push_back("BALANCINGDAMPER"); + items.push_back("BLASTDAMPER"); + items.push_back("CONTROLDAMPER"); + items.push_back("FIREDAMPER"); + items.push_back("FIRESMOKEDAMPER"); + items.push_back("FUMEHOODEXHAUST"); + items.push_back("GRAVITYDAMPER"); + items.push_back("GRAVITYRELIEFDAMPER"); + items.push_back("NOTDEFINED"); + items.push_back("RELIEFDAMPER"); + items.push_back("SMOKEDAMPER"); + items.push_back("USERDEFINED"); + IfcDamperTypeEnum_type = new enumeration_type("IfcDamperTypeEnum", items); + } + declaration* IfcDataOriginEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("MEASURED"); + items.push_back("NOTDEFINED"); + items.push_back("PREDICTED"); + items.push_back("SIMULATED"); + items.push_back("USERDEFINED"); + IfcDataOriginEnum_type = new enumeration_type("IfcDataOriginEnum", items); + } + declaration* IfcDerivedUnitEnum_type; + { + std::vector items; items.reserve(49); + items.push_back("ACCELERATIONUNIT"); + items.push_back("ANGULARVELOCITYUNIT"); + items.push_back("COMPOUNDPLANEANGLEUNIT"); + items.push_back("CURVATUREUNIT"); + items.push_back("DYNAMICVISCOSITYUNIT"); + items.push_back("HEATFLUXDENSITYUNIT"); + items.push_back("HEATINGVALUEUNIT"); + items.push_back("INTEGERCOUNTRATEUNIT"); + items.push_back("IONCONCENTRATIONUNIT"); + items.push_back("ISOTHERMALMOISTURECAPACITYUNIT"); + items.push_back("KINEMATICVISCOSITYUNIT"); + items.push_back("LINEARFORCEUNIT"); + items.push_back("LINEARMOMENTUNIT"); + items.push_back("LINEARSTIFFNESSUNIT"); + items.push_back("LINEARVELOCITYUNIT"); + items.push_back("LUMINOUSINTENSITYDISTRIBUTIONUNIT"); + items.push_back("MASSDENSITYUNIT"); + items.push_back("MASSFLOWRATEUNIT"); + items.push_back("MASSPERLENGTHUNIT"); + items.push_back("MODULUSOFELASTICITYUNIT"); + items.push_back("MODULUSOFLINEARSUBGRADEREACTIONUNIT"); + items.push_back("MODULUSOFROTATIONALSUBGRADEREACTIONUNIT"); + items.push_back("MODULUSOFSUBGRADEREACTIONUNIT"); + items.push_back("MOISTUREDIFFUSIVITYUNIT"); + items.push_back("MOLECULARWEIGHTUNIT"); + items.push_back("MOMENTOFINERTIAUNIT"); + items.push_back("PHUNIT"); + items.push_back("PLANARFORCEUNIT"); + items.push_back("ROTATIONALFREQUENCYUNIT"); + items.push_back("ROTATIONALMASSUNIT"); + items.push_back("ROTATIONALSTIFFNESSUNIT"); + items.push_back("SECTIONAREAINTEGRALUNIT"); + items.push_back("SECTIONMODULUSUNIT"); + items.push_back("SHEARMODULUSUNIT"); + items.push_back("SOUNDPOWERUNIT"); + items.push_back("SOUNDPRESSUREUNIT"); + items.push_back("SPECIFICHEATCAPACITYUNIT"); + items.push_back("TEMPERATUREGRADIENTUNIT"); + items.push_back("THERMALADMITTANCEUNIT"); + items.push_back("THERMALCONDUCTANCEUNIT"); + items.push_back("THERMALEXPANSIONCOEFFICIENTUNIT"); + items.push_back("THERMALRESISTANCEUNIT"); + items.push_back("THERMALTRANSMITTANCEUNIT"); + items.push_back("TORQUEUNIT"); + items.push_back("USERDEFINED"); + items.push_back("VAPORPERMEABILITYUNIT"); + items.push_back("VOLUMETRICFLOWRATEUNIT"); + items.push_back("WARPINGCONSTANTUNIT"); + items.push_back("WARPINGMOMENTUNIT"); + IfcDerivedUnitEnum_type = new enumeration_type("IfcDerivedUnitEnum", items); + } + declaration* IfcDimensionExtentUsage_type; + { + std::vector items; items.reserve(2); + items.push_back("ORIGIN"); + items.push_back("TARGET"); + IfcDimensionExtentUsage_type = new enumeration_type("IfcDimensionExtentUsage", items); + } + declaration* IfcDirectionSenseEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("NEGATIVE"); + items.push_back("POSITIVE"); + IfcDirectionSenseEnum_type = new enumeration_type("IfcDirectionSenseEnum", items); + } + declaration* IfcDistributionChamberElementTypeEnum_type; + { + std::vector items; items.reserve(10); + items.push_back("FORMEDDUCT"); + items.push_back("INSPECTIONCHAMBER"); + items.push_back("INSPECTIONPIT"); + items.push_back("MANHOLE"); + items.push_back("METERCHAMBER"); + items.push_back("NOTDEFINED"); + items.push_back("SUMP"); + items.push_back("TRENCH"); + items.push_back("USERDEFINED"); + items.push_back("VALVECHAMBER"); + IfcDistributionChamberElementTypeEnum_type = new enumeration_type("IfcDistributionChamberElementTypeEnum", items); + } + declaration* IfcDocumentConfidentialityEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("CONFIDENTIAL"); + items.push_back("NOTDEFINED"); + items.push_back("PERSONAL"); + items.push_back("PUBLIC"); + items.push_back("RESTRICTED"); + items.push_back("USERDEFINED"); + IfcDocumentConfidentialityEnum_type = new enumeration_type("IfcDocumentConfidentialityEnum", items); + } + declaration* IfcDocumentStatusEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("DRAFT"); + items.push_back("FINAL"); + items.push_back("FINALDRAFT"); + items.push_back("NOTDEFINED"); + items.push_back("REVISION"); + IfcDocumentStatusEnum_type = new enumeration_type("IfcDocumentStatusEnum", items); + } + declaration* IfcDoorPanelOperationEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("DOUBLE_ACTING"); + items.push_back("FOLDING"); + items.push_back("NOTDEFINED"); + items.push_back("REVOLVING"); + items.push_back("ROLLINGUP"); + items.push_back("SLIDING"); + items.push_back("SWINGING"); + items.push_back("USERDEFINED"); + IfcDoorPanelOperationEnum_type = new enumeration_type("IfcDoorPanelOperationEnum", items); + } + declaration* IfcDoorPanelPositionEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("LEFT"); + items.push_back("MIDDLE"); + items.push_back("NOTDEFINED"); + items.push_back("RIGHT"); + IfcDoorPanelPositionEnum_type = new enumeration_type("IfcDoorPanelPositionEnum", items); + } + declaration* IfcDoorStyleConstructionEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("ALUMINIUM"); + items.push_back("ALUMINIUM_PLASTIC"); + items.push_back("ALUMINIUM_WOOD"); + items.push_back("HIGH_GRADE_STEEL"); + items.push_back("NOTDEFINED"); + items.push_back("PLASTIC"); + items.push_back("STEEL"); + items.push_back("USERDEFINED"); + items.push_back("WOOD"); + IfcDoorStyleConstructionEnum_type = new enumeration_type("IfcDoorStyleConstructionEnum", items); + } + declaration* IfcDoorStyleOperationEnum_type; + { + std::vector items; items.reserve(18); + items.push_back("DOUBLE_DOOR_DOUBLE_SWING"); + items.push_back("DOUBLE_DOOR_FOLDING"); + items.push_back("DOUBLE_DOOR_SINGLE_SWING"); + items.push_back("DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT"); + items.push_back("DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT"); + items.push_back("DOUBLE_DOOR_SLIDING"); + items.push_back("DOUBLE_SWING_LEFT"); + items.push_back("DOUBLE_SWING_RIGHT"); + items.push_back("FOLDING_TO_LEFT"); + items.push_back("FOLDING_TO_RIGHT"); + items.push_back("NOTDEFINED"); + items.push_back("REVOLVING"); + items.push_back("ROLLINGUP"); + items.push_back("SINGLE_SWING_LEFT"); + items.push_back("SINGLE_SWING_RIGHT"); + items.push_back("SLIDING_TO_LEFT"); + items.push_back("SLIDING_TO_RIGHT"); + items.push_back("USERDEFINED"); + IfcDoorStyleOperationEnum_type = new enumeration_type("IfcDoorStyleOperationEnum", items); + } + declaration* IfcDuctFittingTypeEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("BEND"); + items.push_back("CONNECTOR"); + items.push_back("ENTRY"); + items.push_back("EXIT"); + items.push_back("JUNCTION"); + items.push_back("NOTDEFINED"); + items.push_back("OBSTRUCTION"); + items.push_back("TRANSITION"); + items.push_back("USERDEFINED"); + IfcDuctFittingTypeEnum_type = new enumeration_type("IfcDuctFittingTypeEnum", items); + } + declaration* IfcDuctSegmentTypeEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("FLEXIBLESEGMENT"); + items.push_back("NOTDEFINED"); + items.push_back("RIGIDSEGMENT"); + items.push_back("USERDEFINED"); + IfcDuctSegmentTypeEnum_type = new enumeration_type("IfcDuctSegmentTypeEnum", items); + } + declaration* IfcDuctSilencerTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("FLATOVAL"); + items.push_back("NOTDEFINED"); + items.push_back("RECTANGULAR"); + items.push_back("ROUND"); + items.push_back("USERDEFINED"); + IfcDuctSilencerTypeEnum_type = new enumeration_type("IfcDuctSilencerTypeEnum", items); + } + declaration* IfcElectricApplianceTypeEnum_type; + { + std::vector items; items.reserve(26); + items.push_back("COMPUTER"); + items.push_back("DIRECTWATERHEATER"); + items.push_back("DISHWASHER"); + items.push_back("ELECTRICCOOKER"); + items.push_back("ELECTRICHEATER"); + items.push_back("FACSIMILE"); + items.push_back("FREESTANDINGFAN"); + items.push_back("FREEZER"); + items.push_back("FRIDGE_FREEZER"); + items.push_back("HANDDRYER"); + items.push_back("INDIRECTWATERHEATER"); + items.push_back("MICROWAVE"); + items.push_back("NOTDEFINED"); + items.push_back("PHOTOCOPIER"); + items.push_back("PRINTER"); + items.push_back("RADIANTHEATER"); + items.push_back("REFRIGERATOR"); + items.push_back("SCANNER"); + items.push_back("TELEPHONE"); + items.push_back("TUMBLEDRYER"); + items.push_back("TV"); + items.push_back("USERDEFINED"); + items.push_back("VENDINGMACHINE"); + items.push_back("WASHINGMACHINE"); + items.push_back("WATERCOOLER"); + items.push_back("WATERHEATER"); + IfcElectricApplianceTypeEnum_type = new enumeration_type("IfcElectricApplianceTypeEnum", items); + } + declaration* IfcElectricCurrentEnum_type; + { + std::vector items; items.reserve(3); + items.push_back("ALTERNATING"); + items.push_back("DIRECT"); + items.push_back("NOTDEFINED"); + IfcElectricCurrentEnum_type = new enumeration_type("IfcElectricCurrentEnum", items); + } + declaration* IfcElectricDistributionPointFunctionEnum_type; + { + std::vector items; items.reserve(11); + items.push_back("ALARMPANEL"); + items.push_back("CONSUMERUNIT"); + items.push_back("CONTROLPANEL"); + items.push_back("DISTRIBUTIONBOARD"); + items.push_back("GASDETECTORPANEL"); + items.push_back("INDICATORPANEL"); + items.push_back("MIMICPANEL"); + items.push_back("MOTORCONTROLCENTRE"); + items.push_back("NOTDEFINED"); + items.push_back("SWITCHBOARD"); + items.push_back("USERDEFINED"); + IfcElectricDistributionPointFunctionEnum_type = new enumeration_type("IfcElectricDistributionPointFunctionEnum", items); + } + declaration* IfcElectricFlowStorageDeviceTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("BATTERY"); + items.push_back("CAPACITORBANK"); + items.push_back("HARMONICFILTER"); + items.push_back("INDUCTORBANK"); + items.push_back("NOTDEFINED"); + items.push_back("UPS"); + items.push_back("USERDEFINED"); + IfcElectricFlowStorageDeviceTypeEnum_type = new enumeration_type("IfcElectricFlowStorageDeviceTypeEnum", items); + } + declaration* IfcElectricGeneratorTypeEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcElectricGeneratorTypeEnum_type = new enumeration_type("IfcElectricGeneratorTypeEnum", items); + } + declaration* IfcElectricHeaterTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("ELECTRICCABLEHEATER"); + items.push_back("ELECTRICMATHEATER"); + items.push_back("ELECTRICPOINTHEATER"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcElectricHeaterTypeEnum_type = new enumeration_type("IfcElectricHeaterTypeEnum", items); + } + declaration* IfcElectricMotorTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("DC"); + items.push_back("INDUCTION"); + items.push_back("NOTDEFINED"); + items.push_back("POLYPHASE"); + items.push_back("RELUCTANCESYNCHRONOUS"); + items.push_back("SYNCHRONOUS"); + items.push_back("USERDEFINED"); + IfcElectricMotorTypeEnum_type = new enumeration_type("IfcElectricMotorTypeEnum", items); + } + declaration* IfcElectricTimeControlTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("NOTDEFINED"); + items.push_back("RELAY"); + items.push_back("TIMECLOCK"); + items.push_back("TIMEDELAY"); + items.push_back("USERDEFINED"); + IfcElectricTimeControlTypeEnum_type = new enumeration_type("IfcElectricTimeControlTypeEnum", items); + } + declaration* IfcElementAssemblyTypeEnum_type; + { + std::vector items; items.reserve(11); + items.push_back("ACCESSORY_ASSEMBLY"); + items.push_back("ARCH"); + items.push_back("BEAM_GRID"); + items.push_back("BRACED_FRAME"); + items.push_back("GIRDER"); + items.push_back("NOTDEFINED"); + items.push_back("REINFORCEMENT_UNIT"); + items.push_back("RIGID_FRAME"); + items.push_back("SLAB_FIELD"); + items.push_back("TRUSS"); + items.push_back("USERDEFINED"); + IfcElementAssemblyTypeEnum_type = new enumeration_type("IfcElementAssemblyTypeEnum", items); + } + declaration* IfcElementCompositionEnum_type; + { + std::vector items; items.reserve(3); + items.push_back("COMPLEX"); + items.push_back("ELEMENT"); + items.push_back("PARTIAL"); + IfcElementCompositionEnum_type = new enumeration_type("IfcElementCompositionEnum", items); + } + declaration* IfcEnergySequenceEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("AUXILIARY"); + items.push_back("NOTDEFINED"); + items.push_back("PRIMARY"); + items.push_back("SECONDARY"); + items.push_back("TERTIARY"); + items.push_back("USERDEFINED"); + IfcEnergySequenceEnum_type = new enumeration_type("IfcEnergySequenceEnum", items); + } + declaration* IfcEnvironmentalImpactCategoryEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("COMBINEDVALUE"); + items.push_back("DISPOSAL"); + items.push_back("EXTRACTION"); + items.push_back("INSTALLATION"); + items.push_back("MANUFACTURE"); + items.push_back("NOTDEFINED"); + items.push_back("TRANSPORTATION"); + items.push_back("USERDEFINED"); + IfcEnvironmentalImpactCategoryEnum_type = new enumeration_type("IfcEnvironmentalImpactCategoryEnum", items); + } + declaration* IfcEvaporativeCoolerTypeEnum_type; + { + std::vector items; items.reserve(11); + items.push_back("DIRECTEVAPORATIVEAIRWASHER"); + items.push_back("DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER"); + items.push_back("DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER"); + items.push_back("DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER"); + items.push_back("DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER"); + items.push_back("INDIRECTDIRECTCOMBINATION"); + items.push_back("INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER"); + items.push_back("INDIRECTEVAPORATIVEPACKAGEAIRCOOLER"); + items.push_back("INDIRECTEVAPORATIVEWETCOIL"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcEvaporativeCoolerTypeEnum_type = new enumeration_type("IfcEvaporativeCoolerTypeEnum", items); + } + declaration* IfcEvaporatorTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("DIRECTEXPANSIONBRAZEDPLATE"); + items.push_back("DIRECTEXPANSIONSHELLANDTUBE"); + items.push_back("DIRECTEXPANSIONTUBEINTUBE"); + items.push_back("FLOODEDSHELLANDTUBE"); + items.push_back("NOTDEFINED"); + items.push_back("SHELLANDCOIL"); + items.push_back("USERDEFINED"); + IfcEvaporatorTypeEnum_type = new enumeration_type("IfcEvaporatorTypeEnum", items); + } + declaration* IfcFanTypeEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("CENTRIFUGALAIRFOIL"); + items.push_back("CENTRIFUGALBACKWARDINCLINEDCURVED"); + items.push_back("CENTRIFUGALFORWARDCURVED"); + items.push_back("CENTRIFUGALRADIAL"); + items.push_back("NOTDEFINED"); + items.push_back("PROPELLORAXIAL"); + items.push_back("TUBEAXIAL"); + items.push_back("USERDEFINED"); + items.push_back("VANEAXIAL"); + IfcFanTypeEnum_type = new enumeration_type("IfcFanTypeEnum", items); + } + declaration* IfcFilterTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("AIRPARTICLEFILTER"); + items.push_back("NOTDEFINED"); + items.push_back("ODORFILTER"); + items.push_back("OILFILTER"); + items.push_back("STRAINER"); + items.push_back("USERDEFINED"); + items.push_back("WATERFILTER"); + IfcFilterTypeEnum_type = new enumeration_type("IfcFilterTypeEnum", items); + } + declaration* IfcFireSuppressionTerminalTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("BREECHINGINLET"); + items.push_back("FIREHYDRANT"); + items.push_back("HOSEREEL"); + items.push_back("NOTDEFINED"); + items.push_back("SPRINKLER"); + items.push_back("SPRINKLERDEFLECTOR"); + items.push_back("USERDEFINED"); + IfcFireSuppressionTerminalTypeEnum_type = new enumeration_type("IfcFireSuppressionTerminalTypeEnum", items); + } + declaration* IfcFlowDirectionEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("NOTDEFINED"); + items.push_back("SINK"); + items.push_back("SOURCE"); + items.push_back("SOURCEANDSINK"); + IfcFlowDirectionEnum_type = new enumeration_type("IfcFlowDirectionEnum", items); + } + declaration* IfcFlowInstrumentTypeEnum_type; + { + std::vector items; items.reserve(10); + items.push_back("AMMETER"); + items.push_back("FREQUENCYMETER"); + items.push_back("NOTDEFINED"); + items.push_back("PHASEANGLEMETER"); + items.push_back("POWERFACTORMETER"); + items.push_back("PRESSUREGAUGE"); + items.push_back("THERMOMETER"); + items.push_back("USERDEFINED"); + items.push_back("VOLTMETER_PEAK"); + items.push_back("VOLTMETER_RMS"); + IfcFlowInstrumentTypeEnum_type = new enumeration_type("IfcFlowInstrumentTypeEnum", items); + } + declaration* IfcFlowMeterTypeEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("ELECTRICMETER"); + items.push_back("ENERGYMETER"); + items.push_back("FLOWMETER"); + items.push_back("GASMETER"); + items.push_back("NOTDEFINED"); + items.push_back("OILMETER"); + items.push_back("USERDEFINED"); + items.push_back("WATERMETER"); + IfcFlowMeterTypeEnum_type = new enumeration_type("IfcFlowMeterTypeEnum", items); + } + declaration* IfcFootingTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("FOOTING_BEAM"); + items.push_back("NOTDEFINED"); + items.push_back("PAD_FOOTING"); + items.push_back("PILE_CAP"); + items.push_back("STRIP_FOOTING"); + items.push_back("USERDEFINED"); + IfcFootingTypeEnum_type = new enumeration_type("IfcFootingTypeEnum", items); + } + declaration* IfcGasTerminalTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("GASAPPLIANCE"); + items.push_back("GASBOOSTER"); + items.push_back("GASBURNER"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcGasTerminalTypeEnum_type = new enumeration_type("IfcGasTerminalTypeEnum", items); + } + declaration* IfcGeometricProjectionEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("ELEVATION_VIEW"); + items.push_back("GRAPH_VIEW"); + items.push_back("MODEL_VIEW"); + items.push_back("NOTDEFINED"); + items.push_back("PLAN_VIEW"); + items.push_back("REFLECTED_PLAN_VIEW"); + items.push_back("SECTION_VIEW"); + items.push_back("SKETCH_VIEW"); + items.push_back("USERDEFINED"); + IfcGeometricProjectionEnum_type = new enumeration_type("IfcGeometricProjectionEnum", items); + } + declaration* IfcGlobalOrLocalEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("GLOBAL_COORDS"); + items.push_back("LOCAL_COORDS"); + IfcGlobalOrLocalEnum_type = new enumeration_type("IfcGlobalOrLocalEnum", items); + } + declaration* IfcHeatExchangerTypeEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("NOTDEFINED"); + items.push_back("PLATE"); + items.push_back("SHELLANDTUBE"); + items.push_back("USERDEFINED"); + IfcHeatExchangerTypeEnum_type = new enumeration_type("IfcHeatExchangerTypeEnum", items); + } + declaration* IfcHumidifierTypeEnum_type; + { + std::vector items; items.reserve(15); + items.push_back("ADIABATICAIRWASHER"); + items.push_back("ADIABATICATOMIZING"); + items.push_back("ADIABATICCOMPRESSEDAIRNOZZLE"); + items.push_back("ADIABATICPAN"); + items.push_back("ADIABATICRIGIDMEDIA"); + items.push_back("ADIABATICULTRASONIC"); + items.push_back("ADIABATICWETTEDELEMENT"); + items.push_back("ASSISTEDBUTANE"); + items.push_back("ASSISTEDELECTRIC"); + items.push_back("ASSISTEDNATURALGAS"); + items.push_back("ASSISTEDPROPANE"); + items.push_back("ASSISTEDSTEAM"); + items.push_back("NOTDEFINED"); + items.push_back("STEAMINJECTION"); + items.push_back("USERDEFINED"); + IfcHumidifierTypeEnum_type = new enumeration_type("IfcHumidifierTypeEnum", items); + } + declaration* IfcInternalOrExternalEnum_type; + { + std::vector items; items.reserve(3); + items.push_back("EXTERNAL"); + items.push_back("INTERNAL"); + items.push_back("NOTDEFINED"); + IfcInternalOrExternalEnum_type = new enumeration_type("IfcInternalOrExternalEnum", items); + } + declaration* IfcInventoryTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("ASSETINVENTORY"); + items.push_back("FURNITUREINVENTORY"); + items.push_back("NOTDEFINED"); + items.push_back("SPACEINVENTORY"); + items.push_back("USERDEFINED"); + IfcInventoryTypeEnum_type = new enumeration_type("IfcInventoryTypeEnum", items); + } + declaration* IfcJunctionBoxTypeEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcJunctionBoxTypeEnum_type = new enumeration_type("IfcJunctionBoxTypeEnum", items); + } + declaration* IfcLampTypeEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("COMPACTFLUORESCENT"); + items.push_back("FLUORESCENT"); + items.push_back("HIGHPRESSUREMERCURY"); + items.push_back("HIGHPRESSURESODIUM"); + items.push_back("METALHALIDE"); + items.push_back("NOTDEFINED"); + items.push_back("TUNGSTENFILAMENT"); + items.push_back("USERDEFINED"); + IfcLampTypeEnum_type = new enumeration_type("IfcLampTypeEnum", items); + } + declaration* IfcLayerSetDirectionEnum_type; + { + std::vector items; items.reserve(3); + items.push_back("AXIS1"); + items.push_back("AXIS2"); + items.push_back("AXIS3"); + IfcLayerSetDirectionEnum_type = new enumeration_type("IfcLayerSetDirectionEnum", items); + } + declaration* IfcLightDistributionCurveEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("NOTDEFINED"); + items.push_back("TYPE_A"); + items.push_back("TYPE_B"); + items.push_back("TYPE_C"); + IfcLightDistributionCurveEnum_type = new enumeration_type("IfcLightDistributionCurveEnum", items); + } + declaration* IfcLightEmissionSourceEnum_type; + { + std::vector items; items.reserve(11); + items.push_back("COMPACTFLUORESCENT"); + items.push_back("FLUORESCENT"); + items.push_back("HIGHPRESSUREMERCURY"); + items.push_back("HIGHPRESSURESODIUM"); + items.push_back("LIGHTEMITTINGDIODE"); + items.push_back("LOWPRESSURESODIUM"); + items.push_back("LOWVOLTAGEHALOGEN"); + items.push_back("MAINVOLTAGEHALOGEN"); + items.push_back("METALHALIDE"); + items.push_back("NOTDEFINED"); + items.push_back("TUNGSTENFILAMENT"); + IfcLightEmissionSourceEnum_type = new enumeration_type("IfcLightEmissionSourceEnum", items); + } + declaration* IfcLightFixtureTypeEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("DIRECTIONSOURCE"); + items.push_back("NOTDEFINED"); + items.push_back("POINTSOURCE"); + items.push_back("USERDEFINED"); + IfcLightFixtureTypeEnum_type = new enumeration_type("IfcLightFixtureTypeEnum", items); + } + declaration* IfcLoadGroupTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("LOAD_CASE"); + items.push_back("LOAD_COMBINATION"); + items.push_back("LOAD_COMBINATION_GROUP"); + items.push_back("LOAD_GROUP"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcLoadGroupTypeEnum_type = new enumeration_type("IfcLoadGroupTypeEnum", items); + } + declaration* IfcLogicalOperatorEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("LOGICALAND"); + items.push_back("LOGICALOR"); + IfcLogicalOperatorEnum_type = new enumeration_type("IfcLogicalOperatorEnum", items); + } + declaration* IfcMemberTypeEnum_type; + { + std::vector items; items.reserve(14); + items.push_back("BRACE"); + items.push_back("CHORD"); + items.push_back("COLLAR"); + items.push_back("MEMBER"); + items.push_back("MULLION"); + items.push_back("NOTDEFINED"); + items.push_back("PLATE"); + items.push_back("POST"); + items.push_back("PURLIN"); + items.push_back("RAFTER"); + items.push_back("STRINGER"); + items.push_back("STRUT"); + items.push_back("STUD"); + items.push_back("USERDEFINED"); + IfcMemberTypeEnum_type = new enumeration_type("IfcMemberTypeEnum", items); + } + declaration* IfcMotorConnectionTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("BELTDRIVE"); + items.push_back("COUPLING"); + items.push_back("DIRECTDRIVE"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcMotorConnectionTypeEnum_type = new enumeration_type("IfcMotorConnectionTypeEnum", items); + } + declaration* IfcNullStyle_type; + { + std::vector items; items.reserve(1); + items.push_back("NULL"); + IfcNullStyle_type = new enumeration_type("IfcNullStyle", items); + } + declaration* IfcObjectTypeEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("ACTOR"); + items.push_back("CONTROL"); + items.push_back("GROUP"); + items.push_back("NOTDEFINED"); + items.push_back("PROCESS"); + items.push_back("PRODUCT"); + items.push_back("PROJECT"); + items.push_back("RESOURCE"); + IfcObjectTypeEnum_type = new enumeration_type("IfcObjectTypeEnum", items); + } + declaration* IfcObjectiveEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("CODECOMPLIANCE"); + items.push_back("DESIGNINTENT"); + items.push_back("HEALTHANDSAFETY"); + items.push_back("NOTDEFINED"); + items.push_back("REQUIREMENT"); + items.push_back("SPECIFICATION"); + items.push_back("TRIGGERCONDITION"); + items.push_back("USERDEFINED"); + IfcObjectiveEnum_type = new enumeration_type("IfcObjectiveEnum", items); + } + declaration* IfcOccupantTypeEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("ASSIGNEE"); + items.push_back("ASSIGNOR"); + items.push_back("LESSEE"); + items.push_back("LESSOR"); + items.push_back("LETTINGAGENT"); + items.push_back("NOTDEFINED"); + items.push_back("OWNER"); + items.push_back("TENANT"); + items.push_back("USERDEFINED"); + IfcOccupantTypeEnum_type = new enumeration_type("IfcOccupantTypeEnum", items); + } + declaration* IfcOutletTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("AUDIOVISUALOUTLET"); + items.push_back("COMMUNICATIONSOUTLET"); + items.push_back("NOTDEFINED"); + items.push_back("POWEROUTLET"); + items.push_back("USERDEFINED"); + IfcOutletTypeEnum_type = new enumeration_type("IfcOutletTypeEnum", items); + } + declaration* IfcPermeableCoveringOperationEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("GRILL"); + items.push_back("LOUVER"); + items.push_back("NOTDEFINED"); + items.push_back("SCREEN"); + items.push_back("USERDEFINED"); + IfcPermeableCoveringOperationEnum_type = new enumeration_type("IfcPermeableCoveringOperationEnum", items); + } + declaration* IfcPhysicalOrVirtualEnum_type; + { + std::vector items; items.reserve(3); + items.push_back("NOTDEFINED"); + items.push_back("PHYSICAL"); + items.push_back("VIRTUAL"); + IfcPhysicalOrVirtualEnum_type = new enumeration_type("IfcPhysicalOrVirtualEnum", items); + } + declaration* IfcPileConstructionEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("CAST_IN_PLACE"); + items.push_back("COMPOSITE"); + items.push_back("NOTDEFINED"); + items.push_back("PRECAST_CONCRETE"); + items.push_back("PREFAB_STEEL"); + items.push_back("USERDEFINED"); + IfcPileConstructionEnum_type = new enumeration_type("IfcPileConstructionEnum", items); + } + declaration* IfcPileTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("COHESION"); + items.push_back("FRICTION"); + items.push_back("NOTDEFINED"); + items.push_back("SUPPORT"); + items.push_back("USERDEFINED"); + IfcPileTypeEnum_type = new enumeration_type("IfcPileTypeEnum", items); + } + declaration* IfcPipeFittingTypeEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("BEND"); + items.push_back("CONNECTOR"); + items.push_back("ENTRY"); + items.push_back("EXIT"); + items.push_back("JUNCTION"); + items.push_back("NOTDEFINED"); + items.push_back("OBSTRUCTION"); + items.push_back("TRANSITION"); + items.push_back("USERDEFINED"); + IfcPipeFittingTypeEnum_type = new enumeration_type("IfcPipeFittingTypeEnum", items); + } + declaration* IfcPipeSegmentTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("FLEXIBLESEGMENT"); + items.push_back("GUTTER"); + items.push_back("NOTDEFINED"); + items.push_back("RIGIDSEGMENT"); + items.push_back("SPOOL"); + items.push_back("USERDEFINED"); + IfcPipeSegmentTypeEnum_type = new enumeration_type("IfcPipeSegmentTypeEnum", items); + } + declaration* IfcPlateTypeEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("CURTAIN_PANEL"); + items.push_back("NOTDEFINED"); + items.push_back("SHEET"); + items.push_back("USERDEFINED"); + IfcPlateTypeEnum_type = new enumeration_type("IfcPlateTypeEnum", items); + } + declaration* IfcProcedureTypeEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("ADVICE_CAUTION"); + items.push_back("ADVICE_NOTE"); + items.push_back("ADVICE_WARNING"); + items.push_back("CALIBRATION"); + items.push_back("DIAGNOSTIC"); + items.push_back("NOTDEFINED"); + items.push_back("SHUTDOWN"); + items.push_back("STARTUP"); + items.push_back("USERDEFINED"); + IfcProcedureTypeEnum_type = new enumeration_type("IfcProcedureTypeEnum", items); + } + declaration* IfcProfileTypeEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("AREA"); + items.push_back("CURVE"); + IfcProfileTypeEnum_type = new enumeration_type("IfcProfileTypeEnum", items); + } + declaration* IfcProjectOrderRecordTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("CHANGE"); + items.push_back("MAINTENANCE"); + items.push_back("MOVE"); + items.push_back("NOTDEFINED"); + items.push_back("PURCHASE"); + items.push_back("USERDEFINED"); + items.push_back("WORK"); + IfcProjectOrderRecordTypeEnum_type = new enumeration_type("IfcProjectOrderRecordTypeEnum", items); + } + declaration* IfcProjectOrderTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("CHANGEORDER"); + items.push_back("MAINTENANCEWORKORDER"); + items.push_back("MOVEORDER"); + items.push_back("NOTDEFINED"); + items.push_back("PURCHASEORDER"); + items.push_back("USERDEFINED"); + items.push_back("WORKORDER"); + IfcProjectOrderTypeEnum_type = new enumeration_type("IfcProjectOrderTypeEnum", items); + } + declaration* IfcProjectedOrTrueLengthEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("PROJECTED_LENGTH"); + items.push_back("TRUE_LENGTH"); + IfcProjectedOrTrueLengthEnum_type = new enumeration_type("IfcProjectedOrTrueLengthEnum", items); + } + declaration* IfcPropertySourceEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("ASBUILT"); + items.push_back("COMMISSIONING"); + items.push_back("DESIGN"); + items.push_back("DESIGNMAXIMUM"); + items.push_back("DESIGNMINIMUM"); + items.push_back("MEASURED"); + items.push_back("NOTKNOWN"); + items.push_back("SIMULATED"); + items.push_back("USERDEFINED"); + IfcPropertySourceEnum_type = new enumeration_type("IfcPropertySourceEnum", items); + } + declaration* IfcProtectiveDeviceTypeEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("CIRCUITBREAKER"); + items.push_back("EARTHFAILUREDEVICE"); + items.push_back("FUSEDISCONNECTOR"); + items.push_back("NOTDEFINED"); + items.push_back("RESIDUALCURRENTCIRCUITBREAKER"); + items.push_back("RESIDUALCURRENTSWITCH"); + items.push_back("USERDEFINED"); + items.push_back("VARISTOR"); + IfcProtectiveDeviceTypeEnum_type = new enumeration_type("IfcProtectiveDeviceTypeEnum", items); + } + declaration* IfcPumpTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("CIRCULATOR"); + items.push_back("ENDSUCTION"); + items.push_back("NOTDEFINED"); + items.push_back("SPLITCASE"); + items.push_back("USERDEFINED"); + items.push_back("VERTICALINLINE"); + items.push_back("VERTICALTURBINE"); + IfcPumpTypeEnum_type = new enumeration_type("IfcPumpTypeEnum", items); + } + declaration* IfcRailingTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("BALUSTRADE"); + items.push_back("GUARDRAIL"); + items.push_back("HANDRAIL"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcRailingTypeEnum_type = new enumeration_type("IfcRailingTypeEnum", items); + } + declaration* IfcRampFlightTypeEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("NOTDEFINED"); + items.push_back("SPIRAL"); + items.push_back("STRAIGHT"); + items.push_back("USERDEFINED"); + IfcRampFlightTypeEnum_type = new enumeration_type("IfcRampFlightTypeEnum", items); + } + declaration* IfcRampTypeEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("HALF_TURN_RAMP"); + items.push_back("NOTDEFINED"); + items.push_back("QUARTER_TURN_RAMP"); + items.push_back("SPIRAL_RAMP"); + items.push_back("STRAIGHT_RUN_RAMP"); + items.push_back("TWO_QUARTER_TURN_RAMP"); + items.push_back("TWO_STRAIGHT_RUN_RAMP"); + items.push_back("USERDEFINED"); + IfcRampTypeEnum_type = new enumeration_type("IfcRampTypeEnum", items); + } + declaration* IfcReflectanceMethodEnum_type; + { + std::vector items; items.reserve(10); + items.push_back("BLINN"); + items.push_back("FLAT"); + items.push_back("GLASS"); + items.push_back("MATT"); + items.push_back("METAL"); + items.push_back("MIRROR"); + items.push_back("NOTDEFINED"); + items.push_back("PHONG"); + items.push_back("PLASTIC"); + items.push_back("STRAUSS"); + IfcReflectanceMethodEnum_type = new enumeration_type("IfcReflectanceMethodEnum", items); + } + declaration* IfcReinforcingBarRoleEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("EDGE"); + items.push_back("LIGATURE"); + items.push_back("MAIN"); + items.push_back("NOTDEFINED"); + items.push_back("PUNCHING"); + items.push_back("RING"); + items.push_back("SHEAR"); + items.push_back("STUD"); + items.push_back("USERDEFINED"); + IfcReinforcingBarRoleEnum_type = new enumeration_type("IfcReinforcingBarRoleEnum", items); + } + declaration* IfcReinforcingBarSurfaceEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("PLAIN"); + items.push_back("TEXTURED"); + IfcReinforcingBarSurfaceEnum_type = new enumeration_type("IfcReinforcingBarSurfaceEnum", items); + } + declaration* IfcResourceConsumptionEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("CONSUMED"); + items.push_back("NOTCONSUMED"); + items.push_back("NOTDEFINED"); + items.push_back("NOTOCCUPIED"); + items.push_back("OCCUPIED"); + items.push_back("PARTIALLYCONSUMED"); + items.push_back("PARTIALLYOCCUPIED"); + items.push_back("USERDEFINED"); + IfcResourceConsumptionEnum_type = new enumeration_type("IfcResourceConsumptionEnum", items); + } + declaration* IfcRibPlateDirectionEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("DIRECTION_X"); + items.push_back("DIRECTION_Y"); + IfcRibPlateDirectionEnum_type = new enumeration_type("IfcRibPlateDirectionEnum", items); + } + declaration* IfcRoleEnum_type; + { + std::vector items; items.reserve(23); + items.push_back("ARCHITECT"); + items.push_back("BUILDINGOPERATOR"); + items.push_back("BUILDINGOWNER"); + items.push_back("CIVILENGINEER"); + items.push_back("CLIENT"); + items.push_back("COMISSIONINGENGINEER"); + items.push_back("CONSTRUCTIONMANAGER"); + items.push_back("CONSULTANT"); + items.push_back("CONTRACTOR"); + items.push_back("COSTENGINEER"); + items.push_back("ELECTRICALENGINEER"); + items.push_back("ENGINEER"); + items.push_back("FACILITIESMANAGER"); + items.push_back("FIELDCONSTRUCTIONMANAGER"); + items.push_back("MANUFACTURER"); + items.push_back("MECHANICALENGINEER"); + items.push_back("OWNER"); + items.push_back("PROJECTMANAGER"); + items.push_back("RESELLER"); + items.push_back("STRUCTURALENGINEER"); + items.push_back("SUBCONTRACTOR"); + items.push_back("SUPPLIER"); + items.push_back("USERDEFINED"); + IfcRoleEnum_type = new enumeration_type("IfcRoleEnum", items); + } + declaration* IfcRoofTypeEnum_type; + { + std::vector items; items.reserve(14); + items.push_back("BARREL_ROOF"); + items.push_back("BUTTERFLY_ROOF"); + items.push_back("DOME_ROOF"); + items.push_back("FLAT_ROOF"); + items.push_back("FREEFORM"); + items.push_back("GABLE_ROOF"); + items.push_back("GAMBREL_ROOF"); + items.push_back("HIPPED_GABLE_ROOF"); + items.push_back("HIP_ROOF"); + items.push_back("MANSARD_ROOF"); + items.push_back("NOTDEFINED"); + items.push_back("PAVILION_ROOF"); + items.push_back("RAINBOW_ROOF"); + items.push_back("SHED_ROOF"); + IfcRoofTypeEnum_type = new enumeration_type("IfcRoofTypeEnum", items); + } + declaration* IfcSIPrefix_type; + { + std::vector items; items.reserve(16); + items.push_back("ATTO"); + items.push_back("CENTI"); + items.push_back("DECA"); + items.push_back("DECI"); + items.push_back("EXA"); + items.push_back("FEMTO"); + items.push_back("GIGA"); + items.push_back("HECTO"); + items.push_back("KILO"); + items.push_back("MEGA"); + items.push_back("MICRO"); + items.push_back("MILLI"); + items.push_back("NANO"); + items.push_back("PETA"); + items.push_back("PICO"); + items.push_back("TERA"); + IfcSIPrefix_type = new enumeration_type("IfcSIPrefix", items); + } + declaration* IfcSIUnitName_type; + { + std::vector items; items.reserve(30); + items.push_back("AMPERE"); + items.push_back("BECQUEREL"); + items.push_back("CANDELA"); + items.push_back("COULOMB"); + items.push_back("CUBIC_METRE"); + items.push_back("DEGREE_CELSIUS"); + items.push_back("FARAD"); + items.push_back("GRAM"); + items.push_back("GRAY"); + items.push_back("HENRY"); + items.push_back("HERTZ"); + items.push_back("JOULE"); + items.push_back("KELVIN"); + items.push_back("LUMEN"); + items.push_back("LUX"); + items.push_back("METRE"); + items.push_back("MOLE"); + items.push_back("NEWTON"); + items.push_back("OHM"); + items.push_back("PASCAL"); + items.push_back("RADIAN"); + items.push_back("SECOND"); + items.push_back("SIEMENS"); + items.push_back("SIEVERT"); + items.push_back("SQUARE_METRE"); + items.push_back("STERADIAN"); + items.push_back("TESLA"); + items.push_back("VOLT"); + items.push_back("WATT"); + items.push_back("WEBER"); + IfcSIUnitName_type = new enumeration_type("IfcSIUnitName", items); + } + declaration* IfcSanitaryTerminalTypeEnum_type; + { + std::vector items; items.reserve(12); + items.push_back("BATH"); + items.push_back("BIDET"); + items.push_back("CISTERN"); + items.push_back("NOTDEFINED"); + items.push_back("SANITARYFOUNTAIN"); + items.push_back("SHOWER"); + items.push_back("SINK"); + items.push_back("TOILETPAN"); + items.push_back("URINAL"); + items.push_back("USERDEFINED"); + items.push_back("WASHHANDBASIN"); + items.push_back("WCSEAT"); + IfcSanitaryTerminalTypeEnum_type = new enumeration_type("IfcSanitaryTerminalTypeEnum", items); + } + declaration* IfcSectionTypeEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("TAPERED"); + items.push_back("UNIFORM"); + IfcSectionTypeEnum_type = new enumeration_type("IfcSectionTypeEnum", items); + } + declaration* IfcSensorTypeEnum_type; + { + std::vector items; items.reserve(15); + items.push_back("CO2SENSOR"); + items.push_back("FIRESENSOR"); + items.push_back("FLOWSENSOR"); + items.push_back("GASSENSOR"); + items.push_back("HEATSENSOR"); + items.push_back("HUMIDITYSENSOR"); + items.push_back("LIGHTSENSOR"); + items.push_back("MOISTURESENSOR"); + items.push_back("MOVEMENTSENSOR"); + items.push_back("NOTDEFINED"); + items.push_back("PRESSURESENSOR"); + items.push_back("SMOKESENSOR"); + items.push_back("SOUNDSENSOR"); + items.push_back("TEMPERATURESENSOR"); + items.push_back("USERDEFINED"); + IfcSensorTypeEnum_type = new enumeration_type("IfcSensorTypeEnum", items); + } + declaration* IfcSequenceEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("FINISH_FINISH"); + items.push_back("FINISH_START"); + items.push_back("NOTDEFINED"); + items.push_back("START_FINISH"); + items.push_back("START_START"); + IfcSequenceEnum_type = new enumeration_type("IfcSequenceEnum", items); + } + declaration* IfcServiceLifeFactorTypeEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("A_QUALITYOFCOMPONENTS"); + items.push_back("B_DESIGNLEVEL"); + items.push_back("C_WORKEXECUTIONLEVEL"); + items.push_back("D_INDOORENVIRONMENT"); + items.push_back("E_OUTDOORENVIRONMENT"); + items.push_back("F_INUSECONDITIONS"); + items.push_back("G_MAINTENANCELEVEL"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcServiceLifeFactorTypeEnum_type = new enumeration_type("IfcServiceLifeFactorTypeEnum", items); + } + declaration* IfcServiceLifeTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("ACTUALSERVICELIFE"); + items.push_back("EXPECTEDSERVICELIFE"); + items.push_back("OPTIMISTICREFERENCESERVICELIFE"); + items.push_back("PESSIMISTICREFERENCESERVICELIFE"); + items.push_back("REFERENCESERVICELIFE"); + IfcServiceLifeTypeEnum_type = new enumeration_type("IfcServiceLifeTypeEnum", items); + } + declaration* IfcSlabTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("BASESLAB"); + items.push_back("FLOOR"); + items.push_back("LANDING"); + items.push_back("NOTDEFINED"); + items.push_back("ROOF"); + items.push_back("USERDEFINED"); + IfcSlabTypeEnum_type = new enumeration_type("IfcSlabTypeEnum", items); + } + declaration* IfcSoundScaleEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("DBA"); + items.push_back("DBB"); + items.push_back("DBC"); + items.push_back("NC"); + items.push_back("NOTDEFINED"); + items.push_back("NR"); + items.push_back("USERDEFINED"); + IfcSoundScaleEnum_type = new enumeration_type("IfcSoundScaleEnum", items); + } + declaration* IfcSpaceHeaterTypeEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("BASEBOARDHEATER"); + items.push_back("CONVECTOR"); + items.push_back("FINNEDTUBEUNIT"); + items.push_back("NOTDEFINED"); + items.push_back("PANELRADIATOR"); + items.push_back("SECTIONALRADIATOR"); + items.push_back("TUBULARRADIATOR"); + items.push_back("UNITHEATER"); + items.push_back("USERDEFINED"); + IfcSpaceHeaterTypeEnum_type = new enumeration_type("IfcSpaceHeaterTypeEnum", items); + } + declaration* IfcSpaceTypeEnum_type; + { + std::vector items; items.reserve(2); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcSpaceTypeEnum_type = new enumeration_type("IfcSpaceTypeEnum", items); + } + declaration* IfcStackTerminalTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("BIRDCAGE"); + items.push_back("COWL"); + items.push_back("NOTDEFINED"); + items.push_back("RAINWATERHOPPER"); + items.push_back("USERDEFINED"); + IfcStackTerminalTypeEnum_type = new enumeration_type("IfcStackTerminalTypeEnum", items); + } + declaration* IfcStairFlightTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("CURVED"); + items.push_back("FREEFORM"); + items.push_back("NOTDEFINED"); + items.push_back("SPIRAL"); + items.push_back("STRAIGHT"); + items.push_back("USERDEFINED"); + items.push_back("WINDER"); + IfcStairFlightTypeEnum_type = new enumeration_type("IfcStairFlightTypeEnum", items); + } + declaration* IfcStairTypeEnum_type; + { + std::vector items; items.reserve(16); + items.push_back("CURVED_RUN_STAIR"); + items.push_back("DOUBLE_RETURN_STAIR"); + items.push_back("HALF_TURN_STAIR"); + items.push_back("HALF_WINDING_STAIR"); + items.push_back("NOTDEFINED"); + items.push_back("QUARTER_TURN_STAIR"); + items.push_back("QUARTER_WINDING_STAIR"); + items.push_back("SPIRAL_STAIR"); + items.push_back("STRAIGHT_RUN_STAIR"); + items.push_back("THREE_QUARTER_TURN_STAIR"); + items.push_back("THREE_QUARTER_WINDING_STAIR"); + items.push_back("TWO_CURVED_RUN_STAIR"); + items.push_back("TWO_QUARTER_TURN_STAIR"); + items.push_back("TWO_QUARTER_WINDING_STAIR"); + items.push_back("TWO_STRAIGHT_RUN_STAIR"); + items.push_back("USERDEFINED"); + IfcStairTypeEnum_type = new enumeration_type("IfcStairTypeEnum", items); + } + declaration* IfcStateEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("LOCKED"); + items.push_back("READONLY"); + items.push_back("READONLYLOCKED"); + items.push_back("READWRITE"); + items.push_back("READWRITELOCKED"); + IfcStateEnum_type = new enumeration_type("IfcStateEnum", items); + } + declaration* IfcStructuralCurveTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("CABLE"); + items.push_back("COMPRESSION_MEMBER"); + items.push_back("NOTDEFINED"); + items.push_back("PIN_JOINED_MEMBER"); + items.push_back("RIGID_JOINED_MEMBER"); + items.push_back("TENSION_MEMBER"); + items.push_back("USERDEFINED"); + IfcStructuralCurveTypeEnum_type = new enumeration_type("IfcStructuralCurveTypeEnum", items); + } + declaration* IfcStructuralSurfaceTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("BENDING_ELEMENT"); + items.push_back("MEMBRANE_ELEMENT"); + items.push_back("NOTDEFINED"); + items.push_back("SHELL"); + items.push_back("USERDEFINED"); + IfcStructuralSurfaceTypeEnum_type = new enumeration_type("IfcStructuralSurfaceTypeEnum", items); + } + declaration* IfcSurfaceSide_type; + { + std::vector items; items.reserve(3); + items.push_back("BOTH"); + items.push_back("NEGATIVE"); + items.push_back("POSITIVE"); + IfcSurfaceSide_type = new enumeration_type("IfcSurfaceSide", items); + } + declaration* IfcSurfaceTextureEnum_type; + { + std::vector items; items.reserve(9); + items.push_back("BUMP"); + items.push_back("NOTDEFINED"); + items.push_back("OPACITY"); + items.push_back("REFLECTION"); + items.push_back("SELFILLUMINATION"); + items.push_back("SHININESS"); + items.push_back("SPECULAR"); + items.push_back("TEXTURE"); + items.push_back("TRANSPARENCYMAP"); + IfcSurfaceTextureEnum_type = new enumeration_type("IfcSurfaceTextureEnum", items); + } + declaration* IfcSwitchingDeviceTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("CONTACTOR"); + items.push_back("EMERGENCYSTOP"); + items.push_back("NOTDEFINED"); + items.push_back("STARTER"); + items.push_back("SWITCHDISCONNECTOR"); + items.push_back("TOGGLESWITCH"); + items.push_back("USERDEFINED"); + IfcSwitchingDeviceTypeEnum_type = new enumeration_type("IfcSwitchingDeviceTypeEnum", items); + } + declaration* IfcTankTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("EXPANSION"); + items.push_back("NOTDEFINED"); + items.push_back("PREFORMED"); + items.push_back("PRESSUREVESSEL"); + items.push_back("SECTIONAL"); + items.push_back("USERDEFINED"); + IfcTankTypeEnum_type = new enumeration_type("IfcTankTypeEnum", items); + } + declaration* IfcTendonTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("BAR"); + items.push_back("COATED"); + items.push_back("NOTDEFINED"); + items.push_back("STRAND"); + items.push_back("USERDEFINED"); + items.push_back("WIRE"); + IfcTendonTypeEnum_type = new enumeration_type("IfcTendonTypeEnum", items); + } + declaration* IfcTextPath_type; + { + std::vector items; items.reserve(4); + items.push_back("DOWN"); + items.push_back("LEFT"); + items.push_back("RIGHT"); + items.push_back("UP"); + IfcTextPath_type = new enumeration_type("IfcTextPath", items); + } + declaration* IfcThermalLoadSourceEnum_type; + { + std::vector items; items.reserve(13); + items.push_back("AIREXCHANGERATE"); + items.push_back("DRYBULBTEMPERATURE"); + items.push_back("EQUIPMENT"); + items.push_back("EXHAUSTAIR"); + items.push_back("INFILTRATION"); + items.push_back("LIGHTING"); + items.push_back("NOTDEFINED"); + items.push_back("PEOPLE"); + items.push_back("RECIRCULATEDAIR"); + items.push_back("RELATIVEHUMIDITY"); + items.push_back("USERDEFINED"); + items.push_back("VENTILATIONINDOORAIR"); + items.push_back("VENTILATIONOUTSIDEAIR"); + IfcThermalLoadSourceEnum_type = new enumeration_type("IfcThermalLoadSourceEnum", items); + } + declaration* IfcThermalLoadTypeEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("LATENT"); + items.push_back("NOTDEFINED"); + items.push_back("RADIANT"); + items.push_back("SENSIBLE"); + IfcThermalLoadTypeEnum_type = new enumeration_type("IfcThermalLoadTypeEnum", items); + } + declaration* IfcTimeSeriesDataTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("CONTINUOUS"); + items.push_back("DISCRETE"); + items.push_back("DISCRETEBINARY"); + items.push_back("NOTDEFINED"); + items.push_back("PIECEWISEBINARY"); + items.push_back("PIECEWISECONSTANT"); + items.push_back("PIECEWISECONTINUOUS"); + IfcTimeSeriesDataTypeEnum_type = new enumeration_type("IfcTimeSeriesDataTypeEnum", items); + } + declaration* IfcTimeSeriesScheduleTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("ANNUAL"); + items.push_back("DAILY"); + items.push_back("MONTHLY"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + items.push_back("WEEKLY"); + IfcTimeSeriesScheduleTypeEnum_type = new enumeration_type("IfcTimeSeriesScheduleTypeEnum", items); + } + declaration* IfcTransformerTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("CURRENT"); + items.push_back("FREQUENCY"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + items.push_back("VOLTAGE"); + IfcTransformerTypeEnum_type = new enumeration_type("IfcTransformerTypeEnum", items); + } + declaration* IfcTransitionCode_type; + { + std::vector items; items.reserve(4); + items.push_back("CONTINUOUS"); + items.push_back("CONTSAMEGRADIENT"); + items.push_back("CONTSAMEGRADIENTSAMECURVATURE"); + items.push_back("DISCONTINUOUS"); + IfcTransitionCode_type = new enumeration_type("IfcTransitionCode", items); + } + declaration* IfcTransportElementTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("ELEVATOR"); + items.push_back("ESCALATOR"); + items.push_back("MOVINGWALKWAY"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcTransportElementTypeEnum_type = new enumeration_type("IfcTransportElementTypeEnum", items); + } + declaration* IfcTrimmingPreference_type; + { + std::vector items; items.reserve(3); + items.push_back("CARTESIAN"); + items.push_back("PARAMETER"); + items.push_back("UNSPECIFIED"); + IfcTrimmingPreference_type = new enumeration_type("IfcTrimmingPreference", items); + } + declaration* IfcTubeBundleTypeEnum_type; + { + std::vector items; items.reserve(3); + items.push_back("FINNED"); + items.push_back("NOTDEFINED"); + items.push_back("USERDEFINED"); + IfcTubeBundleTypeEnum_type = new enumeration_type("IfcTubeBundleTypeEnum", items); + } + declaration* IfcUnitEnum_type; + { + std::vector items; items.reserve(30); + items.push_back("ABSORBEDDOSEUNIT"); + items.push_back("AMOUNTOFSUBSTANCEUNIT"); + items.push_back("AREAUNIT"); + items.push_back("DOSEEQUIVALENTUNIT"); + items.push_back("ELECTRICCAPACITANCEUNIT"); + items.push_back("ELECTRICCHARGEUNIT"); + items.push_back("ELECTRICCONDUCTANCEUNIT"); + items.push_back("ELECTRICCURRENTUNIT"); + items.push_back("ELECTRICRESISTANCEUNIT"); + items.push_back("ELECTRICVOLTAGEUNIT"); + items.push_back("ENERGYUNIT"); + items.push_back("FORCEUNIT"); + items.push_back("FREQUENCYUNIT"); + items.push_back("ILLUMINANCEUNIT"); + items.push_back("INDUCTANCEUNIT"); + items.push_back("LENGTHUNIT"); + items.push_back("LUMINOUSFLUXUNIT"); + items.push_back("LUMINOUSINTENSITYUNIT"); + items.push_back("MAGNETICFLUXDENSITYUNIT"); + items.push_back("MAGNETICFLUXUNIT"); + items.push_back("MASSUNIT"); + items.push_back("PLANEANGLEUNIT"); + items.push_back("POWERUNIT"); + items.push_back("PRESSUREUNIT"); + items.push_back("RADIOACTIVITYUNIT"); + items.push_back("SOLIDANGLEUNIT"); + items.push_back("THERMODYNAMICTEMPERATUREUNIT"); + items.push_back("TIMEUNIT"); + items.push_back("USERDEFINED"); + items.push_back("VOLUMEUNIT"); + IfcUnitEnum_type = new enumeration_type("IfcUnitEnum", items); + } + declaration* IfcUnitaryEquipmentTypeEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("AIRCONDITIONINGUNIT"); + items.push_back("AIRHANDLER"); + items.push_back("NOTDEFINED"); + items.push_back("ROOFTOPUNIT"); + items.push_back("SPLITSYSTEM"); + items.push_back("USERDEFINED"); + IfcUnitaryEquipmentTypeEnum_type = new enumeration_type("IfcUnitaryEquipmentTypeEnum", items); + } + declaration* IfcValveTypeEnum_type; + { + std::vector items; items.reserve(23); + items.push_back("AIRRELEASE"); + items.push_back("ANTIVACUUM"); + items.push_back("CHANGEOVER"); + items.push_back("CHECK"); + items.push_back("COMMISSIONING"); + items.push_back("DIVERTING"); + items.push_back("DOUBLECHECK"); + items.push_back("DOUBLEREGULATING"); + items.push_back("DRAWOFFCOCK"); + items.push_back("FAUCET"); + items.push_back("FLUSHING"); + items.push_back("GASCOCK"); + items.push_back("GASTAP"); + items.push_back("ISOLATING"); + items.push_back("MIXING"); + items.push_back("NOTDEFINED"); + items.push_back("PRESSUREREDUCING"); + items.push_back("PRESSURERELIEF"); + items.push_back("REGULATING"); + items.push_back("SAFETYCUTOFF"); + items.push_back("STEAMTRAP"); + items.push_back("STOPCOCK"); + items.push_back("USERDEFINED"); + IfcValveTypeEnum_type = new enumeration_type("IfcValveTypeEnum", items); + } + declaration* IfcVibrationIsolatorTypeEnum_type; + { + std::vector items; items.reserve(4); + items.push_back("COMPRESSION"); + items.push_back("NOTDEFINED"); + items.push_back("SPRING"); + items.push_back("USERDEFINED"); + IfcVibrationIsolatorTypeEnum_type = new enumeration_type("IfcVibrationIsolatorTypeEnum", items); + } + declaration* IfcWallTypeEnum_type; + { + std::vector items; items.reserve(7); + items.push_back("ELEMENTEDWALL"); + items.push_back("NOTDEFINED"); + items.push_back("PLUMBINGWALL"); + items.push_back("POLYGONAL"); + items.push_back("SHEAR"); + items.push_back("STANDARD"); + items.push_back("USERDEFINED"); + IfcWallTypeEnum_type = new enumeration_type("IfcWallTypeEnum", items); + } + declaration* IfcWasteTerminalTypeEnum_type; + { + std::vector items; items.reserve(12); + items.push_back("FLOORTRAP"); + items.push_back("FLOORWASTE"); + items.push_back("GREASEINTERCEPTOR"); + items.push_back("GULLYSUMP"); + items.push_back("GULLYTRAP"); + items.push_back("NOTDEFINED"); + items.push_back("OILINTERCEPTOR"); + items.push_back("PETROLINTERCEPTOR"); + items.push_back("ROOFDRAIN"); + items.push_back("USERDEFINED"); + items.push_back("WASTEDISPOSALUNIT"); + items.push_back("WASTETRAP"); + IfcWasteTerminalTypeEnum_type = new enumeration_type("IfcWasteTerminalTypeEnum", items); + } + declaration* IfcWindowPanelOperationEnum_type; + { + std::vector items; items.reserve(14); + items.push_back("BOTTOMHUNG"); + items.push_back("FIXEDCASEMENT"); + items.push_back("NOTDEFINED"); + items.push_back("OTHEROPERATION"); + items.push_back("PIVOTHORIZONTAL"); + items.push_back("PIVOTVERTICAL"); + items.push_back("REMOVABLECASEMENT"); + items.push_back("SIDEHUNGLEFTHAND"); + items.push_back("SIDEHUNGRIGHTHAND"); + items.push_back("SLIDINGHORIZONTAL"); + items.push_back("SLIDINGVERTICAL"); + items.push_back("TILTANDTURNLEFTHAND"); + items.push_back("TILTANDTURNRIGHTHAND"); + items.push_back("TOPHUNG"); + IfcWindowPanelOperationEnum_type = new enumeration_type("IfcWindowPanelOperationEnum", items); + } + declaration* IfcWindowPanelPositionEnum_type; + { + std::vector items; items.reserve(6); + items.push_back("BOTTOM"); + items.push_back("LEFT"); + items.push_back("MIDDLE"); + items.push_back("NOTDEFINED"); + items.push_back("RIGHT"); + items.push_back("TOP"); + IfcWindowPanelPositionEnum_type = new enumeration_type("IfcWindowPanelPositionEnum", items); + } + declaration* IfcWindowStyleConstructionEnum_type; + { + std::vector items; items.reserve(8); + items.push_back("ALUMINIUM"); + items.push_back("ALUMINIUM_WOOD"); + items.push_back("HIGH_GRADE_STEEL"); + items.push_back("NOTDEFINED"); + items.push_back("OTHER_CONSTRUCTION"); + items.push_back("PLASTIC"); + items.push_back("STEEL"); + items.push_back("WOOD"); + IfcWindowStyleConstructionEnum_type = new enumeration_type("IfcWindowStyleConstructionEnum", items); + } + declaration* IfcWindowStyleOperationEnum_type; + { + std::vector items; items.reserve(11); + items.push_back("DOUBLE_PANEL_HORIZONTAL"); + items.push_back("DOUBLE_PANEL_VERTICAL"); + items.push_back("NOTDEFINED"); + items.push_back("SINGLE_PANEL"); + items.push_back("TRIPLE_PANEL_BOTTOM"); + items.push_back("TRIPLE_PANEL_HORIZONTAL"); + items.push_back("TRIPLE_PANEL_LEFT"); + items.push_back("TRIPLE_PANEL_RIGHT"); + items.push_back("TRIPLE_PANEL_TOP"); + items.push_back("TRIPLE_PANEL_VERTICAL"); + items.push_back("USERDEFINED"); + IfcWindowStyleOperationEnum_type = new enumeration_type("IfcWindowStyleOperationEnum", items); + } + declaration* IfcWorkControlTypeEnum_type; + { + std::vector items; items.reserve(5); + items.push_back("ACTUAL"); + items.push_back("BASELINE"); + items.push_back("NOTDEFINED"); + items.push_back("PLANNED"); + items.push_back("USERDEFINED"); + IfcWorkControlTypeEnum_type = new enumeration_type("IfcWorkControlTypeEnum", items); + } + entity* IfcActorRole_type = new entity("IfcActorRole", 0); + entity* IfcAddress_type = new entity("IfcAddress", 0); + entity* IfcApplication_type = new entity("IfcApplication", 0); + entity* IfcAppliedValue_type = new entity("IfcAppliedValue", 0); + entity* IfcAppliedValueRelationship_type = new entity("IfcAppliedValueRelationship", 0); + entity* IfcApproval_type = new entity("IfcApproval", 0); + entity* IfcApprovalActorRelationship_type = new entity("IfcApprovalActorRelationship", 0); + entity* IfcApprovalPropertyRelationship_type = new entity("IfcApprovalPropertyRelationship", 0); + entity* IfcApprovalRelationship_type = new entity("IfcApprovalRelationship", 0); + entity* IfcBoundaryCondition_type = new entity("IfcBoundaryCondition", 0); + entity* IfcBoundaryEdgeCondition_type = new entity("IfcBoundaryEdgeCondition", IfcBoundaryCondition_type); + entity* IfcBoundaryFaceCondition_type = new entity("IfcBoundaryFaceCondition", IfcBoundaryCondition_type); + entity* IfcBoundaryNodeCondition_type = new entity("IfcBoundaryNodeCondition", IfcBoundaryCondition_type); + entity* IfcBoundaryNodeConditionWarping_type = new entity("IfcBoundaryNodeConditionWarping", IfcBoundaryNodeCondition_type); + entity* IfcCalendarDate_type = new entity("IfcCalendarDate", 0); + entity* IfcClassification_type = new entity("IfcClassification", 0); + entity* IfcClassificationItem_type = new entity("IfcClassificationItem", 0); + entity* IfcClassificationItemRelationship_type = new entity("IfcClassificationItemRelationship", 0); + entity* IfcClassificationNotation_type = new entity("IfcClassificationNotation", 0); + entity* IfcClassificationNotationFacet_type = new entity("IfcClassificationNotationFacet", 0); + entity* IfcColourSpecification_type = new entity("IfcColourSpecification", 0); + entity* IfcConnectionGeometry_type = new entity("IfcConnectionGeometry", 0); + entity* IfcConnectionPointGeometry_type = new entity("IfcConnectionPointGeometry", IfcConnectionGeometry_type); + entity* IfcConnectionPortGeometry_type = new entity("IfcConnectionPortGeometry", IfcConnectionGeometry_type); + entity* IfcConnectionSurfaceGeometry_type = new entity("IfcConnectionSurfaceGeometry", IfcConnectionGeometry_type); + entity* IfcConstraint_type = new entity("IfcConstraint", 0); + entity* IfcConstraintAggregationRelationship_type = new entity("IfcConstraintAggregationRelationship", 0); + entity* IfcConstraintClassificationRelationship_type = new entity("IfcConstraintClassificationRelationship", 0); + entity* IfcConstraintRelationship_type = new entity("IfcConstraintRelationship", 0); + entity* IfcCoordinatedUniversalTimeOffset_type = new entity("IfcCoordinatedUniversalTimeOffset", 0); + entity* IfcCostValue_type = new entity("IfcCostValue", IfcAppliedValue_type); + entity* IfcCurrencyRelationship_type = new entity("IfcCurrencyRelationship", 0); + entity* IfcCurveStyleFont_type = new entity("IfcCurveStyleFont", 0); + entity* IfcCurveStyleFontAndScaling_type = new entity("IfcCurveStyleFontAndScaling", 0); + entity* IfcCurveStyleFontPattern_type = new entity("IfcCurveStyleFontPattern", 0); + entity* IfcDateAndTime_type = new entity("IfcDateAndTime", 0); + entity* IfcDerivedUnit_type = new entity("IfcDerivedUnit", 0); + entity* IfcDerivedUnitElement_type = new entity("IfcDerivedUnitElement", 0); + entity* IfcDimensionalExponents_type = new entity("IfcDimensionalExponents", 0); + entity* IfcDocumentElectronicFormat_type = new entity("IfcDocumentElectronicFormat", 0); + entity* IfcDocumentInformation_type = new entity("IfcDocumentInformation", 0); + entity* IfcDocumentInformationRelationship_type = new entity("IfcDocumentInformationRelationship", 0); + entity* IfcDraughtingCalloutRelationship_type = new entity("IfcDraughtingCalloutRelationship", 0); + entity* IfcEnvironmentalImpactValue_type = new entity("IfcEnvironmentalImpactValue", IfcAppliedValue_type); + entity* IfcExternalReference_type = new entity("IfcExternalReference", 0); + entity* IfcExternallyDefinedHatchStyle_type = new entity("IfcExternallyDefinedHatchStyle", IfcExternalReference_type); + entity* IfcExternallyDefinedSurfaceStyle_type = new entity("IfcExternallyDefinedSurfaceStyle", IfcExternalReference_type); + entity* IfcExternallyDefinedSymbol_type = new entity("IfcExternallyDefinedSymbol", IfcExternalReference_type); + entity* IfcExternallyDefinedTextFont_type = new entity("IfcExternallyDefinedTextFont", IfcExternalReference_type); + entity* IfcGridAxis_type = new entity("IfcGridAxis", 0); + entity* IfcIrregularTimeSeriesValue_type = new entity("IfcIrregularTimeSeriesValue", 0); + entity* IfcLibraryInformation_type = new entity("IfcLibraryInformation", 0); + entity* IfcLibraryReference_type = new entity("IfcLibraryReference", IfcExternalReference_type); + entity* IfcLightDistributionData_type = new entity("IfcLightDistributionData", 0); + entity* IfcLightIntensityDistribution_type = new entity("IfcLightIntensityDistribution", 0); + entity* IfcLocalTime_type = new entity("IfcLocalTime", 0); + entity* IfcMaterial_type = new entity("IfcMaterial", 0); + entity* IfcMaterialClassificationRelationship_type = new entity("IfcMaterialClassificationRelationship", 0); + entity* IfcMaterialLayer_type = new entity("IfcMaterialLayer", 0); + entity* IfcMaterialLayerSet_type = new entity("IfcMaterialLayerSet", 0); + entity* IfcMaterialLayerSetUsage_type = new entity("IfcMaterialLayerSetUsage", 0); + entity* IfcMaterialList_type = new entity("IfcMaterialList", 0); + entity* IfcMaterialProperties_type = new entity("IfcMaterialProperties", 0); + entity* IfcMeasureWithUnit_type = new entity("IfcMeasureWithUnit", 0); + entity* IfcMechanicalMaterialProperties_type = new entity("IfcMechanicalMaterialProperties", IfcMaterialProperties_type); + entity* IfcMechanicalSteelMaterialProperties_type = new entity("IfcMechanicalSteelMaterialProperties", IfcMechanicalMaterialProperties_type); + entity* IfcMetric_type = new entity("IfcMetric", IfcConstraint_type); + entity* IfcMonetaryUnit_type = new entity("IfcMonetaryUnit", 0); + entity* IfcNamedUnit_type = new entity("IfcNamedUnit", 0); + entity* IfcObjectPlacement_type = new entity("IfcObjectPlacement", 0); + entity* IfcObjective_type = new entity("IfcObjective", IfcConstraint_type); + entity* IfcOpticalMaterialProperties_type = new entity("IfcOpticalMaterialProperties", IfcMaterialProperties_type); + entity* IfcOrganization_type = new entity("IfcOrganization", 0); + entity* IfcOrganizationRelationship_type = new entity("IfcOrganizationRelationship", 0); + entity* IfcOwnerHistory_type = new entity("IfcOwnerHistory", 0); + entity* IfcPerson_type = new entity("IfcPerson", 0); + entity* IfcPersonAndOrganization_type = new entity("IfcPersonAndOrganization", 0); + entity* IfcPhysicalQuantity_type = new entity("IfcPhysicalQuantity", 0); + entity* IfcPhysicalSimpleQuantity_type = new entity("IfcPhysicalSimpleQuantity", IfcPhysicalQuantity_type); + entity* IfcPostalAddress_type = new entity("IfcPostalAddress", IfcAddress_type); + entity* IfcPreDefinedItem_type = new entity("IfcPreDefinedItem", 0); + entity* IfcPreDefinedSymbol_type = new entity("IfcPreDefinedSymbol", IfcPreDefinedItem_type); + entity* IfcPreDefinedTerminatorSymbol_type = new entity("IfcPreDefinedTerminatorSymbol", IfcPreDefinedSymbol_type); + entity* IfcPreDefinedTextFont_type = new entity("IfcPreDefinedTextFont", IfcPreDefinedItem_type); + entity* IfcPresentationLayerAssignment_type = new entity("IfcPresentationLayerAssignment", 0); + entity* IfcPresentationLayerWithStyle_type = new entity("IfcPresentationLayerWithStyle", IfcPresentationLayerAssignment_type); + entity* IfcPresentationStyle_type = new entity("IfcPresentationStyle", 0); + entity* IfcPresentationStyleAssignment_type = new entity("IfcPresentationStyleAssignment", 0); + entity* IfcProductRepresentation_type = new entity("IfcProductRepresentation", 0); + entity* IfcProductsOfCombustionProperties_type = new entity("IfcProductsOfCombustionProperties", IfcMaterialProperties_type); + entity* IfcProfileDef_type = new entity("IfcProfileDef", 0); + entity* IfcProfileProperties_type = new entity("IfcProfileProperties", 0); + entity* IfcProperty_type = new entity("IfcProperty", 0); + entity* IfcPropertyConstraintRelationship_type = new entity("IfcPropertyConstraintRelationship", 0); + entity* IfcPropertyDependencyRelationship_type = new entity("IfcPropertyDependencyRelationship", 0); + entity* IfcPropertyEnumeration_type = new entity("IfcPropertyEnumeration", 0); + entity* IfcQuantityArea_type = new entity("IfcQuantityArea", IfcPhysicalSimpleQuantity_type); + entity* IfcQuantityCount_type = new entity("IfcQuantityCount", IfcPhysicalSimpleQuantity_type); + entity* IfcQuantityLength_type = new entity("IfcQuantityLength", IfcPhysicalSimpleQuantity_type); + entity* IfcQuantityTime_type = new entity("IfcQuantityTime", IfcPhysicalSimpleQuantity_type); + entity* IfcQuantityVolume_type = new entity("IfcQuantityVolume", IfcPhysicalSimpleQuantity_type); + entity* IfcQuantityWeight_type = new entity("IfcQuantityWeight", IfcPhysicalSimpleQuantity_type); + entity* IfcReferencesValueDocument_type = new entity("IfcReferencesValueDocument", 0); + entity* IfcReinforcementBarProperties_type = new entity("IfcReinforcementBarProperties", 0); + entity* IfcRelaxation_type = new entity("IfcRelaxation", 0); + entity* IfcRepresentation_type = new entity("IfcRepresentation", 0); + entity* IfcRepresentationContext_type = new entity("IfcRepresentationContext", 0); + entity* IfcRepresentationItem_type = new entity("IfcRepresentationItem", 0); + entity* IfcRepresentationMap_type = new entity("IfcRepresentationMap", 0); + entity* IfcRibPlateProfileProperties_type = new entity("IfcRibPlateProfileProperties", IfcProfileProperties_type); + entity* IfcRoot_type = new entity("IfcRoot", 0); + entity* IfcSIUnit_type = new entity("IfcSIUnit", IfcNamedUnit_type); + entity* IfcSectionProperties_type = new entity("IfcSectionProperties", 0); + entity* IfcSectionReinforcementProperties_type = new entity("IfcSectionReinforcementProperties", 0); + entity* IfcShapeAspect_type = new entity("IfcShapeAspect", 0); + entity* IfcShapeModel_type = new entity("IfcShapeModel", IfcRepresentation_type); + entity* IfcShapeRepresentation_type = new entity("IfcShapeRepresentation", IfcShapeModel_type); + entity* IfcSimpleProperty_type = new entity("IfcSimpleProperty", IfcProperty_type); + entity* IfcStructuralConnectionCondition_type = new entity("IfcStructuralConnectionCondition", 0); + entity* IfcStructuralLoad_type = new entity("IfcStructuralLoad", 0); + entity* IfcStructuralLoadStatic_type = new entity("IfcStructuralLoadStatic", IfcStructuralLoad_type); + entity* IfcStructuralLoadTemperature_type = new entity("IfcStructuralLoadTemperature", IfcStructuralLoadStatic_type); + entity* IfcStyleModel_type = new entity("IfcStyleModel", IfcRepresentation_type); + entity* IfcStyledItem_type = new entity("IfcStyledItem", IfcRepresentationItem_type); + entity* IfcStyledRepresentation_type = new entity("IfcStyledRepresentation", IfcStyleModel_type); + entity* IfcSurfaceStyle_type = new entity("IfcSurfaceStyle", IfcPresentationStyle_type); + entity* IfcSurfaceStyleLighting_type = new entity("IfcSurfaceStyleLighting", 0); + entity* IfcSurfaceStyleRefraction_type = new entity("IfcSurfaceStyleRefraction", 0); + entity* IfcSurfaceStyleShading_type = new entity("IfcSurfaceStyleShading", 0); + entity* IfcSurfaceStyleWithTextures_type = new entity("IfcSurfaceStyleWithTextures", 0); + entity* IfcSurfaceTexture_type = new entity("IfcSurfaceTexture", 0); + entity* IfcSymbolStyle_type = new entity("IfcSymbolStyle", IfcPresentationStyle_type); + entity* IfcTable_type = new entity("IfcTable", 0); + entity* IfcTableRow_type = new entity("IfcTableRow", 0); + entity* IfcTelecomAddress_type = new entity("IfcTelecomAddress", IfcAddress_type); + entity* IfcTextStyle_type = new entity("IfcTextStyle", IfcPresentationStyle_type); + entity* IfcTextStyleFontModel_type = new entity("IfcTextStyleFontModel", IfcPreDefinedTextFont_type); + entity* IfcTextStyleForDefinedFont_type = new entity("IfcTextStyleForDefinedFont", 0); + entity* IfcTextStyleTextModel_type = new entity("IfcTextStyleTextModel", 0); + entity* IfcTextStyleWithBoxCharacteristics_type = new entity("IfcTextStyleWithBoxCharacteristics", 0); + entity* IfcTextureCoordinate_type = new entity("IfcTextureCoordinate", 0); + entity* IfcTextureCoordinateGenerator_type = new entity("IfcTextureCoordinateGenerator", IfcTextureCoordinate_type); + entity* IfcTextureMap_type = new entity("IfcTextureMap", IfcTextureCoordinate_type); + entity* IfcTextureVertex_type = new entity("IfcTextureVertex", 0); + entity* IfcThermalMaterialProperties_type = new entity("IfcThermalMaterialProperties", IfcMaterialProperties_type); + entity* IfcTimeSeries_type = new entity("IfcTimeSeries", 0); + entity* IfcTimeSeriesReferenceRelationship_type = new entity("IfcTimeSeriesReferenceRelationship", 0); + entity* IfcTimeSeriesValue_type = new entity("IfcTimeSeriesValue", 0); + entity* IfcTopologicalRepresentationItem_type = new entity("IfcTopologicalRepresentationItem", IfcRepresentationItem_type); + entity* IfcTopologyRepresentation_type = new entity("IfcTopologyRepresentation", IfcShapeModel_type); + entity* IfcUnitAssignment_type = new entity("IfcUnitAssignment", 0); + entity* IfcVertex_type = new entity("IfcVertex", IfcTopologicalRepresentationItem_type); + entity* IfcVertexBasedTextureMap_type = new entity("IfcVertexBasedTextureMap", 0); + entity* IfcVertexPoint_type = new entity("IfcVertexPoint", IfcVertex_type); + entity* IfcVirtualGridIntersection_type = new entity("IfcVirtualGridIntersection", 0); + entity* IfcWaterProperties_type = new entity("IfcWaterProperties", IfcMaterialProperties_type); + entity* IfcAnnotationOccurrence_type = new entity("IfcAnnotationOccurrence", IfcStyledItem_type); + entity* IfcAnnotationSurfaceOccurrence_type = new entity("IfcAnnotationSurfaceOccurrence", IfcAnnotationOccurrence_type); + entity* IfcAnnotationSymbolOccurrence_type = new entity("IfcAnnotationSymbolOccurrence", IfcAnnotationOccurrence_type); + entity* IfcAnnotationTextOccurrence_type = new entity("IfcAnnotationTextOccurrence", IfcAnnotationOccurrence_type); + entity* IfcArbitraryClosedProfileDef_type = new entity("IfcArbitraryClosedProfileDef", IfcProfileDef_type); + entity* IfcArbitraryOpenProfileDef_type = new entity("IfcArbitraryOpenProfileDef", IfcProfileDef_type); + entity* IfcArbitraryProfileDefWithVoids_type = new entity("IfcArbitraryProfileDefWithVoids", IfcArbitraryClosedProfileDef_type); + entity* IfcBlobTexture_type = new entity("IfcBlobTexture", IfcSurfaceTexture_type); + entity* IfcCenterLineProfileDef_type = new entity("IfcCenterLineProfileDef", IfcArbitraryOpenProfileDef_type); + entity* IfcClassificationReference_type = new entity("IfcClassificationReference", IfcExternalReference_type); + entity* IfcColourRgb_type = new entity("IfcColourRgb", IfcColourSpecification_type); + entity* IfcComplexProperty_type = new entity("IfcComplexProperty", IfcProperty_type); + entity* IfcCompositeProfileDef_type = new entity("IfcCompositeProfileDef", IfcProfileDef_type); + entity* IfcConnectedFaceSet_type = new entity("IfcConnectedFaceSet", IfcTopologicalRepresentationItem_type); + entity* IfcConnectionCurveGeometry_type = new entity("IfcConnectionCurveGeometry", IfcConnectionGeometry_type); + entity* IfcConnectionPointEccentricity_type = new entity("IfcConnectionPointEccentricity", IfcConnectionPointGeometry_type); + entity* IfcContextDependentUnit_type = new entity("IfcContextDependentUnit", IfcNamedUnit_type); + entity* IfcConversionBasedUnit_type = new entity("IfcConversionBasedUnit", IfcNamedUnit_type); + entity* IfcCurveStyle_type = new entity("IfcCurveStyle", IfcPresentationStyle_type); + entity* IfcDerivedProfileDef_type = new entity("IfcDerivedProfileDef", IfcProfileDef_type); + entity* IfcDimensionCalloutRelationship_type = new entity("IfcDimensionCalloutRelationship", IfcDraughtingCalloutRelationship_type); + entity* IfcDimensionPair_type = new entity("IfcDimensionPair", IfcDraughtingCalloutRelationship_type); + entity* IfcDocumentReference_type = new entity("IfcDocumentReference", IfcExternalReference_type); + entity* IfcDraughtingPreDefinedTextFont_type = new entity("IfcDraughtingPreDefinedTextFont", IfcPreDefinedTextFont_type); + entity* IfcEdge_type = new entity("IfcEdge", IfcTopologicalRepresentationItem_type); + entity* IfcEdgeCurve_type = new entity("IfcEdgeCurve", IfcEdge_type); + entity* IfcExtendedMaterialProperties_type = new entity("IfcExtendedMaterialProperties", IfcMaterialProperties_type); + entity* IfcFace_type = new entity("IfcFace", IfcTopologicalRepresentationItem_type); + entity* IfcFaceBound_type = new entity("IfcFaceBound", IfcTopologicalRepresentationItem_type); + entity* IfcFaceOuterBound_type = new entity("IfcFaceOuterBound", IfcFaceBound_type); + entity* IfcFaceSurface_type = new entity("IfcFaceSurface", IfcFace_type); + entity* IfcFailureConnectionCondition_type = new entity("IfcFailureConnectionCondition", IfcStructuralConnectionCondition_type); + entity* IfcFillAreaStyle_type = new entity("IfcFillAreaStyle", IfcPresentationStyle_type); + entity* IfcFuelProperties_type = new entity("IfcFuelProperties", IfcMaterialProperties_type); + entity* IfcGeneralMaterialProperties_type = new entity("IfcGeneralMaterialProperties", IfcMaterialProperties_type); + entity* IfcGeneralProfileProperties_type = new entity("IfcGeneralProfileProperties", IfcProfileProperties_type); + entity* IfcGeometricRepresentationContext_type = new entity("IfcGeometricRepresentationContext", IfcRepresentationContext_type); + entity* IfcGeometricRepresentationItem_type = new entity("IfcGeometricRepresentationItem", IfcRepresentationItem_type); + entity* IfcGeometricRepresentationSubContext_type = new entity("IfcGeometricRepresentationSubContext", IfcGeometricRepresentationContext_type); + entity* IfcGeometricSet_type = new entity("IfcGeometricSet", IfcGeometricRepresentationItem_type); + entity* IfcGridPlacement_type = new entity("IfcGridPlacement", IfcObjectPlacement_type); + entity* IfcHalfSpaceSolid_type = new entity("IfcHalfSpaceSolid", IfcGeometricRepresentationItem_type); + entity* IfcHygroscopicMaterialProperties_type = new entity("IfcHygroscopicMaterialProperties", IfcMaterialProperties_type); + entity* IfcImageTexture_type = new entity("IfcImageTexture", IfcSurfaceTexture_type); + entity* IfcIrregularTimeSeries_type = new entity("IfcIrregularTimeSeries", IfcTimeSeries_type); + entity* IfcLightSource_type = new entity("IfcLightSource", IfcGeometricRepresentationItem_type); + entity* IfcLightSourceAmbient_type = new entity("IfcLightSourceAmbient", IfcLightSource_type); + entity* IfcLightSourceDirectional_type = new entity("IfcLightSourceDirectional", IfcLightSource_type); + entity* IfcLightSourceGoniometric_type = new entity("IfcLightSourceGoniometric", IfcLightSource_type); + entity* IfcLightSourcePositional_type = new entity("IfcLightSourcePositional", IfcLightSource_type); + entity* IfcLightSourceSpot_type = new entity("IfcLightSourceSpot", IfcLightSourcePositional_type); + entity* IfcLocalPlacement_type = new entity("IfcLocalPlacement", IfcObjectPlacement_type); + entity* IfcLoop_type = new entity("IfcLoop", IfcTopologicalRepresentationItem_type); + entity* IfcMappedItem_type = new entity("IfcMappedItem", IfcRepresentationItem_type); + entity* IfcMaterialDefinitionRepresentation_type = new entity("IfcMaterialDefinitionRepresentation", IfcProductRepresentation_type); + entity* IfcMechanicalConcreteMaterialProperties_type = new entity("IfcMechanicalConcreteMaterialProperties", IfcMechanicalMaterialProperties_type); + entity* IfcObjectDefinition_type = new entity("IfcObjectDefinition", IfcRoot_type); + entity* IfcOneDirectionRepeatFactor_type = new entity("IfcOneDirectionRepeatFactor", IfcGeometricRepresentationItem_type); + entity* IfcOpenShell_type = new entity("IfcOpenShell", IfcConnectedFaceSet_type); + entity* IfcOrientedEdge_type = new entity("IfcOrientedEdge", IfcEdge_type); + entity* IfcParameterizedProfileDef_type = new entity("IfcParameterizedProfileDef", IfcProfileDef_type); + entity* IfcPath_type = new entity("IfcPath", IfcTopologicalRepresentationItem_type); + entity* IfcPhysicalComplexQuantity_type = new entity("IfcPhysicalComplexQuantity", IfcPhysicalQuantity_type); + entity* IfcPixelTexture_type = new entity("IfcPixelTexture", IfcSurfaceTexture_type); + entity* IfcPlacement_type = new entity("IfcPlacement", IfcGeometricRepresentationItem_type); + entity* IfcPlanarExtent_type = new entity("IfcPlanarExtent", IfcGeometricRepresentationItem_type); + entity* IfcPoint_type = new entity("IfcPoint", IfcGeometricRepresentationItem_type); + entity* IfcPointOnCurve_type = new entity("IfcPointOnCurve", IfcPoint_type); + entity* IfcPointOnSurface_type = new entity("IfcPointOnSurface", IfcPoint_type); + entity* IfcPolyLoop_type = new entity("IfcPolyLoop", IfcLoop_type); + entity* IfcPolygonalBoundedHalfSpace_type = new entity("IfcPolygonalBoundedHalfSpace", IfcHalfSpaceSolid_type); + entity* IfcPreDefinedColour_type = new entity("IfcPreDefinedColour", IfcPreDefinedItem_type); + entity* IfcPreDefinedCurveFont_type = new entity("IfcPreDefinedCurveFont", IfcPreDefinedItem_type); + entity* IfcPreDefinedDimensionSymbol_type = new entity("IfcPreDefinedDimensionSymbol", IfcPreDefinedSymbol_type); + entity* IfcPreDefinedPointMarkerSymbol_type = new entity("IfcPreDefinedPointMarkerSymbol", IfcPreDefinedSymbol_type); + entity* IfcProductDefinitionShape_type = new entity("IfcProductDefinitionShape", IfcProductRepresentation_type); + entity* IfcPropertyBoundedValue_type = new entity("IfcPropertyBoundedValue", IfcSimpleProperty_type); + entity* IfcPropertyDefinition_type = new entity("IfcPropertyDefinition", IfcRoot_type); + entity* IfcPropertyEnumeratedValue_type = new entity("IfcPropertyEnumeratedValue", IfcSimpleProperty_type); + entity* IfcPropertyListValue_type = new entity("IfcPropertyListValue", IfcSimpleProperty_type); + entity* IfcPropertyReferenceValue_type = new entity("IfcPropertyReferenceValue", IfcSimpleProperty_type); + entity* IfcPropertySetDefinition_type = new entity("IfcPropertySetDefinition", IfcPropertyDefinition_type); + entity* IfcPropertySingleValue_type = new entity("IfcPropertySingleValue", IfcSimpleProperty_type); + entity* IfcPropertyTableValue_type = new entity("IfcPropertyTableValue", IfcSimpleProperty_type); + entity* IfcRectangleProfileDef_type = new entity("IfcRectangleProfileDef", IfcParameterizedProfileDef_type); + entity* IfcRegularTimeSeries_type = new entity("IfcRegularTimeSeries", IfcTimeSeries_type); + entity* IfcReinforcementDefinitionProperties_type = new entity("IfcReinforcementDefinitionProperties", IfcPropertySetDefinition_type); + entity* IfcRelationship_type = new entity("IfcRelationship", IfcRoot_type); + entity* IfcRoundedRectangleProfileDef_type = new entity("IfcRoundedRectangleProfileDef", IfcRectangleProfileDef_type); + entity* IfcSectionedSpine_type = new entity("IfcSectionedSpine", IfcGeometricRepresentationItem_type); + entity* IfcServiceLifeFactor_type = new entity("IfcServiceLifeFactor", IfcPropertySetDefinition_type); + entity* IfcShellBasedSurfaceModel_type = new entity("IfcShellBasedSurfaceModel", IfcGeometricRepresentationItem_type); + entity* IfcSlippageConnectionCondition_type = new entity("IfcSlippageConnectionCondition", IfcStructuralConnectionCondition_type); + entity* IfcSolidModel_type = new entity("IfcSolidModel", IfcGeometricRepresentationItem_type); + entity* IfcSoundProperties_type = new entity("IfcSoundProperties", IfcPropertySetDefinition_type); + entity* IfcSoundValue_type = new entity("IfcSoundValue", IfcPropertySetDefinition_type); + entity* IfcSpaceThermalLoadProperties_type = new entity("IfcSpaceThermalLoadProperties", IfcPropertySetDefinition_type); + entity* IfcStructuralLoadLinearForce_type = new entity("IfcStructuralLoadLinearForce", IfcStructuralLoadStatic_type); + entity* IfcStructuralLoadPlanarForce_type = new entity("IfcStructuralLoadPlanarForce", IfcStructuralLoadStatic_type); + entity* IfcStructuralLoadSingleDisplacement_type = new entity("IfcStructuralLoadSingleDisplacement", IfcStructuralLoadStatic_type); + entity* IfcStructuralLoadSingleDisplacementDistortion_type = new entity("IfcStructuralLoadSingleDisplacementDistortion", IfcStructuralLoadSingleDisplacement_type); + entity* IfcStructuralLoadSingleForce_type = new entity("IfcStructuralLoadSingleForce", IfcStructuralLoadStatic_type); + entity* IfcStructuralLoadSingleForceWarping_type = new entity("IfcStructuralLoadSingleForceWarping", IfcStructuralLoadSingleForce_type); + entity* IfcStructuralProfileProperties_type = new entity("IfcStructuralProfileProperties", IfcGeneralProfileProperties_type); + entity* IfcStructuralSteelProfileProperties_type = new entity("IfcStructuralSteelProfileProperties", IfcStructuralProfileProperties_type); + entity* IfcSubedge_type = new entity("IfcSubedge", IfcEdge_type); + entity* IfcSurface_type = new entity("IfcSurface", IfcGeometricRepresentationItem_type); + entity* IfcSurfaceStyleRendering_type = new entity("IfcSurfaceStyleRendering", IfcSurfaceStyleShading_type); + entity* IfcSweptAreaSolid_type = new entity("IfcSweptAreaSolid", IfcSolidModel_type); + entity* IfcSweptDiskSolid_type = new entity("IfcSweptDiskSolid", IfcSolidModel_type); + entity* IfcSweptSurface_type = new entity("IfcSweptSurface", IfcSurface_type); + entity* IfcTShapeProfileDef_type = new entity("IfcTShapeProfileDef", IfcParameterizedProfileDef_type); + entity* IfcTerminatorSymbol_type = new entity("IfcTerminatorSymbol", IfcAnnotationSymbolOccurrence_type); + entity* IfcTextLiteral_type = new entity("IfcTextLiteral", IfcGeometricRepresentationItem_type); + entity* IfcTextLiteralWithExtent_type = new entity("IfcTextLiteralWithExtent", IfcTextLiteral_type); + entity* IfcTrapeziumProfileDef_type = new entity("IfcTrapeziumProfileDef", IfcParameterizedProfileDef_type); + entity* IfcTwoDirectionRepeatFactor_type = new entity("IfcTwoDirectionRepeatFactor", IfcOneDirectionRepeatFactor_type); + entity* IfcTypeObject_type = new entity("IfcTypeObject", IfcObjectDefinition_type); + entity* IfcTypeProduct_type = new entity("IfcTypeProduct", IfcTypeObject_type); + entity* IfcUShapeProfileDef_type = new entity("IfcUShapeProfileDef", IfcParameterizedProfileDef_type); + entity* IfcVector_type = new entity("IfcVector", IfcGeometricRepresentationItem_type); + entity* IfcVertexLoop_type = new entity("IfcVertexLoop", IfcLoop_type); + entity* IfcWindowLiningProperties_type = new entity("IfcWindowLiningProperties", IfcPropertySetDefinition_type); + entity* IfcWindowPanelProperties_type = new entity("IfcWindowPanelProperties", IfcPropertySetDefinition_type); + entity* IfcWindowStyle_type = new entity("IfcWindowStyle", IfcTypeProduct_type); + entity* IfcZShapeProfileDef_type = new entity("IfcZShapeProfileDef", IfcParameterizedProfileDef_type); + entity* IfcAnnotationCurveOccurrence_type = new entity("IfcAnnotationCurveOccurrence", IfcAnnotationOccurrence_type); + entity* IfcAnnotationFillArea_type = new entity("IfcAnnotationFillArea", IfcGeometricRepresentationItem_type); + entity* IfcAnnotationFillAreaOccurrence_type = new entity("IfcAnnotationFillAreaOccurrence", IfcAnnotationOccurrence_type); + entity* IfcAnnotationSurface_type = new entity("IfcAnnotationSurface", IfcGeometricRepresentationItem_type); + entity* IfcAxis1Placement_type = new entity("IfcAxis1Placement", IfcPlacement_type); + entity* IfcAxis2Placement2D_type = new entity("IfcAxis2Placement2D", IfcPlacement_type); + entity* IfcAxis2Placement3D_type = new entity("IfcAxis2Placement3D", IfcPlacement_type); + entity* IfcBooleanResult_type = new entity("IfcBooleanResult", IfcGeometricRepresentationItem_type); + entity* IfcBoundedSurface_type = new entity("IfcBoundedSurface", IfcSurface_type); + entity* IfcBoundingBox_type = new entity("IfcBoundingBox", IfcGeometricRepresentationItem_type); + entity* IfcBoxedHalfSpace_type = new entity("IfcBoxedHalfSpace", IfcHalfSpaceSolid_type); + entity* IfcCShapeProfileDef_type = new entity("IfcCShapeProfileDef", IfcParameterizedProfileDef_type); + entity* IfcCartesianPoint_type = new entity("IfcCartesianPoint", IfcPoint_type); + entity* IfcCartesianTransformationOperator_type = new entity("IfcCartesianTransformationOperator", IfcGeometricRepresentationItem_type); + entity* IfcCartesianTransformationOperator2D_type = new entity("IfcCartesianTransformationOperator2D", IfcCartesianTransformationOperator_type); + entity* IfcCartesianTransformationOperator2DnonUniform_type = new entity("IfcCartesianTransformationOperator2DnonUniform", IfcCartesianTransformationOperator2D_type); + entity* IfcCartesianTransformationOperator3D_type = new entity("IfcCartesianTransformationOperator3D", IfcCartesianTransformationOperator_type); + entity* IfcCartesianTransformationOperator3DnonUniform_type = new entity("IfcCartesianTransformationOperator3DnonUniform", IfcCartesianTransformationOperator3D_type); + entity* IfcCircleProfileDef_type = new entity("IfcCircleProfileDef", IfcParameterizedProfileDef_type); + entity* IfcClosedShell_type = new entity("IfcClosedShell", IfcConnectedFaceSet_type); + entity* IfcCompositeCurveSegment_type = new entity("IfcCompositeCurveSegment", IfcGeometricRepresentationItem_type); + entity* IfcCraneRailAShapeProfileDef_type = new entity("IfcCraneRailAShapeProfileDef", IfcParameterizedProfileDef_type); + entity* IfcCraneRailFShapeProfileDef_type = new entity("IfcCraneRailFShapeProfileDef", IfcParameterizedProfileDef_type); + entity* IfcCsgPrimitive3D_type = new entity("IfcCsgPrimitive3D", IfcGeometricRepresentationItem_type); + entity* IfcCsgSolid_type = new entity("IfcCsgSolid", IfcSolidModel_type); + entity* IfcCurve_type = new entity("IfcCurve", IfcGeometricRepresentationItem_type); + entity* IfcCurveBoundedPlane_type = new entity("IfcCurveBoundedPlane", IfcBoundedSurface_type); + entity* IfcDefinedSymbol_type = new entity("IfcDefinedSymbol", IfcGeometricRepresentationItem_type); + entity* IfcDimensionCurve_type = new entity("IfcDimensionCurve", IfcAnnotationCurveOccurrence_type); + entity* IfcDimensionCurveTerminator_type = new entity("IfcDimensionCurveTerminator", IfcTerminatorSymbol_type); + entity* IfcDirection_type = new entity("IfcDirection", IfcGeometricRepresentationItem_type); + entity* IfcDoorLiningProperties_type = new entity("IfcDoorLiningProperties", IfcPropertySetDefinition_type); + entity* IfcDoorPanelProperties_type = new entity("IfcDoorPanelProperties", IfcPropertySetDefinition_type); + entity* IfcDoorStyle_type = new entity("IfcDoorStyle", IfcTypeProduct_type); + entity* IfcDraughtingCallout_type = new entity("IfcDraughtingCallout", IfcGeometricRepresentationItem_type); + entity* IfcDraughtingPreDefinedColour_type = new entity("IfcDraughtingPreDefinedColour", IfcPreDefinedColour_type); + entity* IfcDraughtingPreDefinedCurveFont_type = new entity("IfcDraughtingPreDefinedCurveFont", IfcPreDefinedCurveFont_type); + entity* IfcEdgeLoop_type = new entity("IfcEdgeLoop", IfcLoop_type); + entity* IfcElementQuantity_type = new entity("IfcElementQuantity", IfcPropertySetDefinition_type); + entity* IfcElementType_type = new entity("IfcElementType", IfcTypeProduct_type); + entity* IfcElementarySurface_type = new entity("IfcElementarySurface", IfcSurface_type); + entity* IfcEllipseProfileDef_type = new entity("IfcEllipseProfileDef", IfcParameterizedProfileDef_type); + entity* IfcEnergyProperties_type = new entity("IfcEnergyProperties", IfcPropertySetDefinition_type); + entity* IfcExtrudedAreaSolid_type = new entity("IfcExtrudedAreaSolid", IfcSweptAreaSolid_type); + entity* IfcFaceBasedSurfaceModel_type = new entity("IfcFaceBasedSurfaceModel", IfcGeometricRepresentationItem_type); + entity* IfcFillAreaStyleHatching_type = new entity("IfcFillAreaStyleHatching", IfcGeometricRepresentationItem_type); + entity* IfcFillAreaStyleTileSymbolWithStyle_type = new entity("IfcFillAreaStyleTileSymbolWithStyle", IfcGeometricRepresentationItem_type); + entity* IfcFillAreaStyleTiles_type = new entity("IfcFillAreaStyleTiles", IfcGeometricRepresentationItem_type); + entity* IfcFluidFlowProperties_type = new entity("IfcFluidFlowProperties", IfcPropertySetDefinition_type); + entity* IfcFurnishingElementType_type = new entity("IfcFurnishingElementType", IfcElementType_type); + entity* IfcFurnitureType_type = new entity("IfcFurnitureType", IfcFurnishingElementType_type); + entity* IfcGeometricCurveSet_type = new entity("IfcGeometricCurveSet", IfcGeometricSet_type); + entity* IfcIShapeProfileDef_type = new entity("IfcIShapeProfileDef", IfcParameterizedProfileDef_type); + entity* IfcLShapeProfileDef_type = new entity("IfcLShapeProfileDef", IfcParameterizedProfileDef_type); + entity* IfcLine_type = new entity("IfcLine", IfcCurve_type); + entity* IfcManifoldSolidBrep_type = new entity("IfcManifoldSolidBrep", IfcSolidModel_type); + entity* IfcObject_type = new entity("IfcObject", IfcObjectDefinition_type); + entity* IfcOffsetCurve2D_type = new entity("IfcOffsetCurve2D", IfcCurve_type); + entity* IfcOffsetCurve3D_type = new entity("IfcOffsetCurve3D", IfcCurve_type); + entity* IfcPermeableCoveringProperties_type = new entity("IfcPermeableCoveringProperties", IfcPropertySetDefinition_type); + entity* IfcPlanarBox_type = new entity("IfcPlanarBox", IfcPlanarExtent_type); + entity* IfcPlane_type = new entity("IfcPlane", IfcElementarySurface_type); + entity* IfcProcess_type = new entity("IfcProcess", IfcObject_type); + entity* IfcProduct_type = new entity("IfcProduct", IfcObject_type); + entity* IfcProject_type = new entity("IfcProject", IfcObject_type); + entity* IfcProjectionCurve_type = new entity("IfcProjectionCurve", IfcAnnotationCurveOccurrence_type); + entity* IfcPropertySet_type = new entity("IfcPropertySet", IfcPropertySetDefinition_type); + entity* IfcProxy_type = new entity("IfcProxy", IfcProduct_type); + entity* IfcRectangleHollowProfileDef_type = new entity("IfcRectangleHollowProfileDef", IfcRectangleProfileDef_type); + entity* IfcRectangularPyramid_type = new entity("IfcRectangularPyramid", IfcCsgPrimitive3D_type); + entity* IfcRectangularTrimmedSurface_type = new entity("IfcRectangularTrimmedSurface", IfcBoundedSurface_type); + entity* IfcRelAssigns_type = new entity("IfcRelAssigns", IfcRelationship_type); + entity* IfcRelAssignsToActor_type = new entity("IfcRelAssignsToActor", IfcRelAssigns_type); + entity* IfcRelAssignsToControl_type = new entity("IfcRelAssignsToControl", IfcRelAssigns_type); + entity* IfcRelAssignsToGroup_type = new entity("IfcRelAssignsToGroup", IfcRelAssigns_type); + entity* IfcRelAssignsToProcess_type = new entity("IfcRelAssignsToProcess", IfcRelAssigns_type); + entity* IfcRelAssignsToProduct_type = new entity("IfcRelAssignsToProduct", IfcRelAssigns_type); + entity* IfcRelAssignsToProjectOrder_type = new entity("IfcRelAssignsToProjectOrder", IfcRelAssignsToControl_type); + entity* IfcRelAssignsToResource_type = new entity("IfcRelAssignsToResource", IfcRelAssigns_type); + entity* IfcRelAssociates_type = new entity("IfcRelAssociates", IfcRelationship_type); + entity* IfcRelAssociatesAppliedValue_type = new entity("IfcRelAssociatesAppliedValue", IfcRelAssociates_type); + entity* IfcRelAssociatesApproval_type = new entity("IfcRelAssociatesApproval", IfcRelAssociates_type); + entity* IfcRelAssociatesClassification_type = new entity("IfcRelAssociatesClassification", IfcRelAssociates_type); + entity* IfcRelAssociatesConstraint_type = new entity("IfcRelAssociatesConstraint", IfcRelAssociates_type); + entity* IfcRelAssociatesDocument_type = new entity("IfcRelAssociatesDocument", IfcRelAssociates_type); + entity* IfcRelAssociatesLibrary_type = new entity("IfcRelAssociatesLibrary", IfcRelAssociates_type); + entity* IfcRelAssociatesMaterial_type = new entity("IfcRelAssociatesMaterial", IfcRelAssociates_type); + entity* IfcRelAssociatesProfileProperties_type = new entity("IfcRelAssociatesProfileProperties", IfcRelAssociates_type); + entity* IfcRelConnects_type = new entity("IfcRelConnects", IfcRelationship_type); + entity* IfcRelConnectsElements_type = new entity("IfcRelConnectsElements", IfcRelConnects_type); + entity* IfcRelConnectsPathElements_type = new entity("IfcRelConnectsPathElements", IfcRelConnectsElements_type); + entity* IfcRelConnectsPortToElement_type = new entity("IfcRelConnectsPortToElement", IfcRelConnects_type); + entity* IfcRelConnectsPorts_type = new entity("IfcRelConnectsPorts", IfcRelConnects_type); + entity* IfcRelConnectsStructuralActivity_type = new entity("IfcRelConnectsStructuralActivity", IfcRelConnects_type); + entity* IfcRelConnectsStructuralElement_type = new entity("IfcRelConnectsStructuralElement", IfcRelConnects_type); + entity* IfcRelConnectsStructuralMember_type = new entity("IfcRelConnectsStructuralMember", IfcRelConnects_type); + entity* IfcRelConnectsWithEccentricity_type = new entity("IfcRelConnectsWithEccentricity", IfcRelConnectsStructuralMember_type); + entity* IfcRelConnectsWithRealizingElements_type = new entity("IfcRelConnectsWithRealizingElements", IfcRelConnectsElements_type); + entity* IfcRelContainedInSpatialStructure_type = new entity("IfcRelContainedInSpatialStructure", IfcRelConnects_type); + entity* IfcRelCoversBldgElements_type = new entity("IfcRelCoversBldgElements", IfcRelConnects_type); + entity* IfcRelCoversSpaces_type = new entity("IfcRelCoversSpaces", IfcRelConnects_type); + entity* IfcRelDecomposes_type = new entity("IfcRelDecomposes", IfcRelationship_type); + entity* IfcRelDefines_type = new entity("IfcRelDefines", IfcRelationship_type); + entity* IfcRelDefinesByProperties_type = new entity("IfcRelDefinesByProperties", IfcRelDefines_type); + entity* IfcRelDefinesByType_type = new entity("IfcRelDefinesByType", IfcRelDefines_type); + entity* IfcRelFillsElement_type = new entity("IfcRelFillsElement", IfcRelConnects_type); + entity* IfcRelFlowControlElements_type = new entity("IfcRelFlowControlElements", IfcRelConnects_type); + entity* IfcRelInteractionRequirements_type = new entity("IfcRelInteractionRequirements", IfcRelConnects_type); + entity* IfcRelNests_type = new entity("IfcRelNests", IfcRelDecomposes_type); + entity* IfcRelOccupiesSpaces_type = new entity("IfcRelOccupiesSpaces", IfcRelAssignsToActor_type); + entity* IfcRelOverridesProperties_type = new entity("IfcRelOverridesProperties", IfcRelDefinesByProperties_type); + entity* IfcRelProjectsElement_type = new entity("IfcRelProjectsElement", IfcRelConnects_type); + entity* IfcRelReferencedInSpatialStructure_type = new entity("IfcRelReferencedInSpatialStructure", IfcRelConnects_type); + entity* IfcRelSchedulesCostItems_type = new entity("IfcRelSchedulesCostItems", IfcRelAssignsToControl_type); + entity* IfcRelSequence_type = new entity("IfcRelSequence", IfcRelConnects_type); + entity* IfcRelServicesBuildings_type = new entity("IfcRelServicesBuildings", IfcRelConnects_type); + entity* IfcRelSpaceBoundary_type = new entity("IfcRelSpaceBoundary", IfcRelConnects_type); + entity* IfcRelVoidsElement_type = new entity("IfcRelVoidsElement", IfcRelConnects_type); + entity* IfcResource_type = new entity("IfcResource", IfcObject_type); + entity* IfcRevolvedAreaSolid_type = new entity("IfcRevolvedAreaSolid", IfcSweptAreaSolid_type); + entity* IfcRightCircularCone_type = new entity("IfcRightCircularCone", IfcCsgPrimitive3D_type); + entity* IfcRightCircularCylinder_type = new entity("IfcRightCircularCylinder", IfcCsgPrimitive3D_type); + entity* IfcSpatialStructureElement_type = new entity("IfcSpatialStructureElement", IfcProduct_type); + entity* IfcSpatialStructureElementType_type = new entity("IfcSpatialStructureElementType", IfcElementType_type); + entity* IfcSphere_type = new entity("IfcSphere", IfcCsgPrimitive3D_type); + entity* IfcStructuralActivity_type = new entity("IfcStructuralActivity", IfcProduct_type); + entity* IfcStructuralItem_type = new entity("IfcStructuralItem", IfcProduct_type); + entity* IfcStructuralMember_type = new entity("IfcStructuralMember", IfcStructuralItem_type); + entity* IfcStructuralReaction_type = new entity("IfcStructuralReaction", IfcStructuralActivity_type); + entity* IfcStructuralSurfaceMember_type = new entity("IfcStructuralSurfaceMember", IfcStructuralMember_type); + entity* IfcStructuralSurfaceMemberVarying_type = new entity("IfcStructuralSurfaceMemberVarying", IfcStructuralSurfaceMember_type); + entity* IfcStructuredDimensionCallout_type = new entity("IfcStructuredDimensionCallout", IfcDraughtingCallout_type); + entity* IfcSurfaceCurveSweptAreaSolid_type = new entity("IfcSurfaceCurveSweptAreaSolid", IfcSweptAreaSolid_type); + entity* IfcSurfaceOfLinearExtrusion_type = new entity("IfcSurfaceOfLinearExtrusion", IfcSweptSurface_type); + entity* IfcSurfaceOfRevolution_type = new entity("IfcSurfaceOfRevolution", IfcSweptSurface_type); + entity* IfcSystemFurnitureElementType_type = new entity("IfcSystemFurnitureElementType", IfcFurnishingElementType_type); + entity* IfcTask_type = new entity("IfcTask", IfcProcess_type); + entity* IfcTransportElementType_type = new entity("IfcTransportElementType", IfcElementType_type); + entity* IfcActor_type = new entity("IfcActor", IfcObject_type); + entity* IfcAnnotation_type = new entity("IfcAnnotation", IfcProduct_type); + entity* IfcAsymmetricIShapeProfileDef_type = new entity("IfcAsymmetricIShapeProfileDef", IfcIShapeProfileDef_type); + entity* IfcBlock_type = new entity("IfcBlock", IfcCsgPrimitive3D_type); + entity* IfcBooleanClippingResult_type = new entity("IfcBooleanClippingResult", IfcBooleanResult_type); + entity* IfcBoundedCurve_type = new entity("IfcBoundedCurve", IfcCurve_type); + entity* IfcBuilding_type = new entity("IfcBuilding", IfcSpatialStructureElement_type); + entity* IfcBuildingElementType_type = new entity("IfcBuildingElementType", IfcElementType_type); + entity* IfcBuildingStorey_type = new entity("IfcBuildingStorey", IfcSpatialStructureElement_type); + entity* IfcCircleHollowProfileDef_type = new entity("IfcCircleHollowProfileDef", IfcCircleProfileDef_type); + entity* IfcColumnType_type = new entity("IfcColumnType", IfcBuildingElementType_type); + entity* IfcCompositeCurve_type = new entity("IfcCompositeCurve", IfcBoundedCurve_type); + entity* IfcConic_type = new entity("IfcConic", IfcCurve_type); + entity* IfcConstructionResource_type = new entity("IfcConstructionResource", IfcResource_type); + entity* IfcControl_type = new entity("IfcControl", IfcObject_type); + entity* IfcCostItem_type = new entity("IfcCostItem", IfcControl_type); + entity* IfcCostSchedule_type = new entity("IfcCostSchedule", IfcControl_type); + entity* IfcCoveringType_type = new entity("IfcCoveringType", IfcBuildingElementType_type); + entity* IfcCrewResource_type = new entity("IfcCrewResource", IfcConstructionResource_type); + entity* IfcCurtainWallType_type = new entity("IfcCurtainWallType", IfcBuildingElementType_type); + entity* IfcDimensionCurveDirectedCallout_type = new entity("IfcDimensionCurveDirectedCallout", IfcDraughtingCallout_type); + entity* IfcDistributionElementType_type = new entity("IfcDistributionElementType", IfcElementType_type); + entity* IfcDistributionFlowElementType_type = new entity("IfcDistributionFlowElementType", IfcDistributionElementType_type); + entity* IfcElectricalBaseProperties_type = new entity("IfcElectricalBaseProperties", IfcEnergyProperties_type); + entity* IfcElement_type = new entity("IfcElement", IfcProduct_type); + entity* IfcElementAssembly_type = new entity("IfcElementAssembly", IfcElement_type); + entity* IfcElementComponent_type = new entity("IfcElementComponent", IfcElement_type); + entity* IfcElementComponentType_type = new entity("IfcElementComponentType", IfcElementType_type); + entity* IfcEllipse_type = new entity("IfcEllipse", IfcConic_type); + entity* IfcEnergyConversionDeviceType_type = new entity("IfcEnergyConversionDeviceType", IfcDistributionFlowElementType_type); + entity* IfcEquipmentElement_type = new entity("IfcEquipmentElement", IfcElement_type); + entity* IfcEquipmentStandard_type = new entity("IfcEquipmentStandard", IfcControl_type); + entity* IfcEvaporativeCoolerType_type = new entity("IfcEvaporativeCoolerType", IfcEnergyConversionDeviceType_type); + entity* IfcEvaporatorType_type = new entity("IfcEvaporatorType", IfcEnergyConversionDeviceType_type); + entity* IfcFacetedBrep_type = new entity("IfcFacetedBrep", IfcManifoldSolidBrep_type); + entity* IfcFacetedBrepWithVoids_type = new entity("IfcFacetedBrepWithVoids", IfcManifoldSolidBrep_type); + entity* IfcFastener_type = new entity("IfcFastener", IfcElementComponent_type); + entity* IfcFastenerType_type = new entity("IfcFastenerType", IfcElementComponentType_type); + entity* IfcFeatureElement_type = new entity("IfcFeatureElement", IfcElement_type); + entity* IfcFeatureElementAddition_type = new entity("IfcFeatureElementAddition", IfcFeatureElement_type); + entity* IfcFeatureElementSubtraction_type = new entity("IfcFeatureElementSubtraction", IfcFeatureElement_type); + entity* IfcFlowControllerType_type = new entity("IfcFlowControllerType", IfcDistributionFlowElementType_type); + entity* IfcFlowFittingType_type = new entity("IfcFlowFittingType", IfcDistributionFlowElementType_type); + entity* IfcFlowMeterType_type = new entity("IfcFlowMeterType", IfcFlowControllerType_type); + entity* IfcFlowMovingDeviceType_type = new entity("IfcFlowMovingDeviceType", IfcDistributionFlowElementType_type); + entity* IfcFlowSegmentType_type = new entity("IfcFlowSegmentType", IfcDistributionFlowElementType_type); + entity* IfcFlowStorageDeviceType_type = new entity("IfcFlowStorageDeviceType", IfcDistributionFlowElementType_type); + entity* IfcFlowTerminalType_type = new entity("IfcFlowTerminalType", IfcDistributionFlowElementType_type); + entity* IfcFlowTreatmentDeviceType_type = new entity("IfcFlowTreatmentDeviceType", IfcDistributionFlowElementType_type); + entity* IfcFurnishingElement_type = new entity("IfcFurnishingElement", IfcElement_type); + entity* IfcFurnitureStandard_type = new entity("IfcFurnitureStandard", IfcControl_type); + entity* IfcGasTerminalType_type = new entity("IfcGasTerminalType", IfcFlowTerminalType_type); + entity* IfcGrid_type = new entity("IfcGrid", IfcProduct_type); + entity* IfcGroup_type = new entity("IfcGroup", IfcObject_type); + entity* IfcHeatExchangerType_type = new entity("IfcHeatExchangerType", IfcEnergyConversionDeviceType_type); + entity* IfcHumidifierType_type = new entity("IfcHumidifierType", IfcEnergyConversionDeviceType_type); + entity* IfcInventory_type = new entity("IfcInventory", IfcGroup_type); + entity* IfcJunctionBoxType_type = new entity("IfcJunctionBoxType", IfcFlowFittingType_type); + entity* IfcLaborResource_type = new entity("IfcLaborResource", IfcConstructionResource_type); + entity* IfcLampType_type = new entity("IfcLampType", IfcFlowTerminalType_type); + entity* IfcLightFixtureType_type = new entity("IfcLightFixtureType", IfcFlowTerminalType_type); + entity* IfcLinearDimension_type = new entity("IfcLinearDimension", IfcDimensionCurveDirectedCallout_type); + entity* IfcMechanicalFastener_type = new entity("IfcMechanicalFastener", IfcFastener_type); + entity* IfcMechanicalFastenerType_type = new entity("IfcMechanicalFastenerType", IfcFastenerType_type); + entity* IfcMemberType_type = new entity("IfcMemberType", IfcBuildingElementType_type); + entity* IfcMotorConnectionType_type = new entity("IfcMotorConnectionType", IfcEnergyConversionDeviceType_type); + entity* IfcMove_type = new entity("IfcMove", IfcTask_type); + entity* IfcOccupant_type = new entity("IfcOccupant", IfcActor_type); + entity* IfcOpeningElement_type = new entity("IfcOpeningElement", IfcFeatureElementSubtraction_type); + entity* IfcOrderAction_type = new entity("IfcOrderAction", IfcTask_type); + entity* IfcOutletType_type = new entity("IfcOutletType", IfcFlowTerminalType_type); + entity* IfcPerformanceHistory_type = new entity("IfcPerformanceHistory", IfcControl_type); + entity* IfcPermit_type = new entity("IfcPermit", IfcControl_type); + entity* IfcPipeFittingType_type = new entity("IfcPipeFittingType", IfcFlowFittingType_type); + entity* IfcPipeSegmentType_type = new entity("IfcPipeSegmentType", IfcFlowSegmentType_type); + entity* IfcPlateType_type = new entity("IfcPlateType", IfcBuildingElementType_type); + entity* IfcPolyline_type = new entity("IfcPolyline", IfcBoundedCurve_type); + entity* IfcPort_type = new entity("IfcPort", IfcProduct_type); + entity* IfcProcedure_type = new entity("IfcProcedure", IfcProcess_type); + entity* IfcProjectOrder_type = new entity("IfcProjectOrder", IfcControl_type); + entity* IfcProjectOrderRecord_type = new entity("IfcProjectOrderRecord", IfcControl_type); + entity* IfcProjectionElement_type = new entity("IfcProjectionElement", IfcFeatureElementAddition_type); + entity* IfcProtectiveDeviceType_type = new entity("IfcProtectiveDeviceType", IfcFlowControllerType_type); + entity* IfcPumpType_type = new entity("IfcPumpType", IfcFlowMovingDeviceType_type); + entity* IfcRadiusDimension_type = new entity("IfcRadiusDimension", IfcDimensionCurveDirectedCallout_type); + entity* IfcRailingType_type = new entity("IfcRailingType", IfcBuildingElementType_type); + entity* IfcRampFlightType_type = new entity("IfcRampFlightType", IfcBuildingElementType_type); + entity* IfcRelAggregates_type = new entity("IfcRelAggregates", IfcRelDecomposes_type); + entity* IfcRelAssignsTasks_type = new entity("IfcRelAssignsTasks", IfcRelAssignsToControl_type); + entity* IfcSanitaryTerminalType_type = new entity("IfcSanitaryTerminalType", IfcFlowTerminalType_type); + entity* IfcScheduleTimeControl_type = new entity("IfcScheduleTimeControl", IfcControl_type); + entity* IfcServiceLife_type = new entity("IfcServiceLife", IfcControl_type); + entity* IfcSite_type = new entity("IfcSite", IfcSpatialStructureElement_type); + entity* IfcSlabType_type = new entity("IfcSlabType", IfcBuildingElementType_type); + entity* IfcSpace_type = new entity("IfcSpace", IfcSpatialStructureElement_type); + entity* IfcSpaceHeaterType_type = new entity("IfcSpaceHeaterType", IfcEnergyConversionDeviceType_type); + entity* IfcSpaceProgram_type = new entity("IfcSpaceProgram", IfcControl_type); + entity* IfcSpaceType_type = new entity("IfcSpaceType", IfcSpatialStructureElementType_type); + entity* IfcStackTerminalType_type = new entity("IfcStackTerminalType", IfcFlowTerminalType_type); + entity* IfcStairFlightType_type = new entity("IfcStairFlightType", IfcBuildingElementType_type); + entity* IfcStructuralAction_type = new entity("IfcStructuralAction", IfcStructuralActivity_type); + entity* IfcStructuralConnection_type = new entity("IfcStructuralConnection", IfcStructuralItem_type); + entity* IfcStructuralCurveConnection_type = new entity("IfcStructuralCurveConnection", IfcStructuralConnection_type); + entity* IfcStructuralCurveMember_type = new entity("IfcStructuralCurveMember", IfcStructuralMember_type); + entity* IfcStructuralCurveMemberVarying_type = new entity("IfcStructuralCurveMemberVarying", IfcStructuralCurveMember_type); + entity* IfcStructuralLinearAction_type = new entity("IfcStructuralLinearAction", IfcStructuralAction_type); + entity* IfcStructuralLinearActionVarying_type = new entity("IfcStructuralLinearActionVarying", IfcStructuralLinearAction_type); + entity* IfcStructuralLoadGroup_type = new entity("IfcStructuralLoadGroup", IfcGroup_type); + entity* IfcStructuralPlanarAction_type = new entity("IfcStructuralPlanarAction", IfcStructuralAction_type); + entity* IfcStructuralPlanarActionVarying_type = new entity("IfcStructuralPlanarActionVarying", IfcStructuralPlanarAction_type); + entity* IfcStructuralPointAction_type = new entity("IfcStructuralPointAction", IfcStructuralAction_type); + entity* IfcStructuralPointConnection_type = new entity("IfcStructuralPointConnection", IfcStructuralConnection_type); + entity* IfcStructuralPointReaction_type = new entity("IfcStructuralPointReaction", IfcStructuralReaction_type); + entity* IfcStructuralResultGroup_type = new entity("IfcStructuralResultGroup", IfcGroup_type); + entity* IfcStructuralSurfaceConnection_type = new entity("IfcStructuralSurfaceConnection", IfcStructuralConnection_type); + entity* IfcSubContractResource_type = new entity("IfcSubContractResource", IfcConstructionResource_type); + entity* IfcSwitchingDeviceType_type = new entity("IfcSwitchingDeviceType", IfcFlowControllerType_type); + entity* IfcSystem_type = new entity("IfcSystem", IfcGroup_type); + entity* IfcTankType_type = new entity("IfcTankType", IfcFlowStorageDeviceType_type); + entity* IfcTimeSeriesSchedule_type = new entity("IfcTimeSeriesSchedule", IfcControl_type); + entity* IfcTransformerType_type = new entity("IfcTransformerType", IfcEnergyConversionDeviceType_type); + entity* IfcTransportElement_type = new entity("IfcTransportElement", IfcElement_type); + entity* IfcTrimmedCurve_type = new entity("IfcTrimmedCurve", IfcBoundedCurve_type); + entity* IfcTubeBundleType_type = new entity("IfcTubeBundleType", IfcEnergyConversionDeviceType_type); + entity* IfcUnitaryEquipmentType_type = new entity("IfcUnitaryEquipmentType", IfcEnergyConversionDeviceType_type); + entity* IfcValveType_type = new entity("IfcValveType", IfcFlowControllerType_type); + entity* IfcVirtualElement_type = new entity("IfcVirtualElement", IfcElement_type); + entity* IfcWallType_type = new entity("IfcWallType", IfcBuildingElementType_type); + entity* IfcWasteTerminalType_type = new entity("IfcWasteTerminalType", IfcFlowTerminalType_type); + entity* IfcWorkControl_type = new entity("IfcWorkControl", IfcControl_type); + entity* IfcWorkPlan_type = new entity("IfcWorkPlan", IfcWorkControl_type); + entity* IfcWorkSchedule_type = new entity("IfcWorkSchedule", IfcWorkControl_type); + entity* IfcZone_type = new entity("IfcZone", IfcGroup_type); + entity* Ifc2DCompositeCurve_type = new entity("Ifc2DCompositeCurve", IfcCompositeCurve_type); + entity* IfcActionRequest_type = new entity("IfcActionRequest", IfcControl_type); + entity* IfcAirTerminalBoxType_type = new entity("IfcAirTerminalBoxType", IfcFlowControllerType_type); + entity* IfcAirTerminalType_type = new entity("IfcAirTerminalType", IfcFlowTerminalType_type); + entity* IfcAirToAirHeatRecoveryType_type = new entity("IfcAirToAirHeatRecoveryType", IfcEnergyConversionDeviceType_type); + entity* IfcAngularDimension_type = new entity("IfcAngularDimension", IfcDimensionCurveDirectedCallout_type); + entity* IfcAsset_type = new entity("IfcAsset", IfcGroup_type); + entity* IfcBSplineCurve_type = new entity("IfcBSplineCurve", IfcBoundedCurve_type); + entity* IfcBeamType_type = new entity("IfcBeamType", IfcBuildingElementType_type); + entity* IfcBezierCurve_type = new entity("IfcBezierCurve", IfcBSplineCurve_type); + entity* IfcBoilerType_type = new entity("IfcBoilerType", IfcEnergyConversionDeviceType_type); + entity* IfcBuildingElement_type = new entity("IfcBuildingElement", IfcElement_type); + entity* IfcBuildingElementComponent_type = new entity("IfcBuildingElementComponent", IfcBuildingElement_type); + entity* IfcBuildingElementPart_type = new entity("IfcBuildingElementPart", IfcBuildingElementComponent_type); + entity* IfcBuildingElementProxy_type = new entity("IfcBuildingElementProxy", IfcBuildingElement_type); + entity* IfcBuildingElementProxyType_type = new entity("IfcBuildingElementProxyType", IfcBuildingElementType_type); + entity* IfcCableCarrierFittingType_type = new entity("IfcCableCarrierFittingType", IfcFlowFittingType_type); + entity* IfcCableCarrierSegmentType_type = new entity("IfcCableCarrierSegmentType", IfcFlowSegmentType_type); + entity* IfcCableSegmentType_type = new entity("IfcCableSegmentType", IfcFlowSegmentType_type); + entity* IfcChillerType_type = new entity("IfcChillerType", IfcEnergyConversionDeviceType_type); + entity* IfcCircle_type = new entity("IfcCircle", IfcConic_type); + entity* IfcCoilType_type = new entity("IfcCoilType", IfcEnergyConversionDeviceType_type); + entity* IfcColumn_type = new entity("IfcColumn", IfcBuildingElement_type); + entity* IfcCompressorType_type = new entity("IfcCompressorType", IfcFlowMovingDeviceType_type); + entity* IfcCondenserType_type = new entity("IfcCondenserType", IfcEnergyConversionDeviceType_type); + entity* IfcCondition_type = new entity("IfcCondition", IfcGroup_type); + entity* IfcConditionCriterion_type = new entity("IfcConditionCriterion", IfcControl_type); + entity* IfcConstructionEquipmentResource_type = new entity("IfcConstructionEquipmentResource", IfcConstructionResource_type); + entity* IfcConstructionMaterialResource_type = new entity("IfcConstructionMaterialResource", IfcConstructionResource_type); + entity* IfcConstructionProductResource_type = new entity("IfcConstructionProductResource", IfcConstructionResource_type); + entity* IfcCooledBeamType_type = new entity("IfcCooledBeamType", IfcEnergyConversionDeviceType_type); + entity* IfcCoolingTowerType_type = new entity("IfcCoolingTowerType", IfcEnergyConversionDeviceType_type); + entity* IfcCovering_type = new entity("IfcCovering", IfcBuildingElement_type); + entity* IfcCurtainWall_type = new entity("IfcCurtainWall", IfcBuildingElement_type); + entity* IfcDamperType_type = new entity("IfcDamperType", IfcFlowControllerType_type); + entity* IfcDiameterDimension_type = new entity("IfcDiameterDimension", IfcDimensionCurveDirectedCallout_type); + entity* IfcDiscreteAccessory_type = new entity("IfcDiscreteAccessory", IfcElementComponent_type); + entity* IfcDiscreteAccessoryType_type = new entity("IfcDiscreteAccessoryType", IfcElementComponentType_type); + entity* IfcDistributionChamberElementType_type = new entity("IfcDistributionChamberElementType", IfcDistributionFlowElementType_type); + entity* IfcDistributionControlElementType_type = new entity("IfcDistributionControlElementType", IfcDistributionElementType_type); + entity* IfcDistributionElement_type = new entity("IfcDistributionElement", IfcElement_type); + entity* IfcDistributionFlowElement_type = new entity("IfcDistributionFlowElement", IfcDistributionElement_type); + entity* IfcDistributionPort_type = new entity("IfcDistributionPort", IfcPort_type); + entity* IfcDoor_type = new entity("IfcDoor", IfcBuildingElement_type); + entity* IfcDuctFittingType_type = new entity("IfcDuctFittingType", IfcFlowFittingType_type); + entity* IfcDuctSegmentType_type = new entity("IfcDuctSegmentType", IfcFlowSegmentType_type); + entity* IfcDuctSilencerType_type = new entity("IfcDuctSilencerType", IfcFlowTreatmentDeviceType_type); + entity* IfcEdgeFeature_type = new entity("IfcEdgeFeature", IfcFeatureElementSubtraction_type); + entity* IfcElectricApplianceType_type = new entity("IfcElectricApplianceType", IfcFlowTerminalType_type); + entity* IfcElectricFlowStorageDeviceType_type = new entity("IfcElectricFlowStorageDeviceType", IfcFlowStorageDeviceType_type); + entity* IfcElectricGeneratorType_type = new entity("IfcElectricGeneratorType", IfcEnergyConversionDeviceType_type); + entity* IfcElectricHeaterType_type = new entity("IfcElectricHeaterType", IfcFlowTerminalType_type); + entity* IfcElectricMotorType_type = new entity("IfcElectricMotorType", IfcEnergyConversionDeviceType_type); + entity* IfcElectricTimeControlType_type = new entity("IfcElectricTimeControlType", IfcFlowControllerType_type); + entity* IfcElectricalCircuit_type = new entity("IfcElectricalCircuit", IfcSystem_type); + entity* IfcElectricalElement_type = new entity("IfcElectricalElement", IfcElement_type); + entity* IfcEnergyConversionDevice_type = new entity("IfcEnergyConversionDevice", IfcDistributionFlowElement_type); + entity* IfcFanType_type = new entity("IfcFanType", IfcFlowMovingDeviceType_type); + entity* IfcFilterType_type = new entity("IfcFilterType", IfcFlowTreatmentDeviceType_type); + entity* IfcFireSuppressionTerminalType_type = new entity("IfcFireSuppressionTerminalType", IfcFlowTerminalType_type); + entity* IfcFlowController_type = new entity("IfcFlowController", IfcDistributionFlowElement_type); + entity* IfcFlowFitting_type = new entity("IfcFlowFitting", IfcDistributionFlowElement_type); + entity* IfcFlowInstrumentType_type = new entity("IfcFlowInstrumentType", IfcDistributionControlElementType_type); + entity* IfcFlowMovingDevice_type = new entity("IfcFlowMovingDevice", IfcDistributionFlowElement_type); + entity* IfcFlowSegment_type = new entity("IfcFlowSegment", IfcDistributionFlowElement_type); + entity* IfcFlowStorageDevice_type = new entity("IfcFlowStorageDevice", IfcDistributionFlowElement_type); + entity* IfcFlowTerminal_type = new entity("IfcFlowTerminal", IfcDistributionFlowElement_type); + entity* IfcFlowTreatmentDevice_type = new entity("IfcFlowTreatmentDevice", IfcDistributionFlowElement_type); + entity* IfcFooting_type = new entity("IfcFooting", IfcBuildingElement_type); + entity* IfcMember_type = new entity("IfcMember", IfcBuildingElement_type); + entity* IfcPile_type = new entity("IfcPile", IfcBuildingElement_type); + entity* IfcPlate_type = new entity("IfcPlate", IfcBuildingElement_type); + entity* IfcRailing_type = new entity("IfcRailing", IfcBuildingElement_type); + entity* IfcRamp_type = new entity("IfcRamp", IfcBuildingElement_type); + entity* IfcRampFlight_type = new entity("IfcRampFlight", IfcBuildingElement_type); + entity* IfcRationalBezierCurve_type = new entity("IfcRationalBezierCurve", IfcBezierCurve_type); + entity* IfcReinforcingElement_type = new entity("IfcReinforcingElement", IfcBuildingElementComponent_type); + entity* IfcReinforcingMesh_type = new entity("IfcReinforcingMesh", IfcReinforcingElement_type); + entity* IfcRoof_type = new entity("IfcRoof", IfcBuildingElement_type); + entity* IfcRoundedEdgeFeature_type = new entity("IfcRoundedEdgeFeature", IfcEdgeFeature_type); + entity* IfcSensorType_type = new entity("IfcSensorType", IfcDistributionControlElementType_type); + entity* IfcSlab_type = new entity("IfcSlab", IfcBuildingElement_type); + entity* IfcStair_type = new entity("IfcStair", IfcBuildingElement_type); + entity* IfcStairFlight_type = new entity("IfcStairFlight", IfcBuildingElement_type); + entity* IfcStructuralAnalysisModel_type = new entity("IfcStructuralAnalysisModel", IfcSystem_type); + entity* IfcTendon_type = new entity("IfcTendon", IfcReinforcingElement_type); + entity* IfcTendonAnchor_type = new entity("IfcTendonAnchor", IfcReinforcingElement_type); + entity* IfcVibrationIsolatorType_type = new entity("IfcVibrationIsolatorType", IfcDiscreteAccessoryType_type); + entity* IfcWall_type = new entity("IfcWall", IfcBuildingElement_type); + entity* IfcWallStandardCase_type = new entity("IfcWallStandardCase", IfcWall_type); + entity* IfcWindow_type = new entity("IfcWindow", IfcBuildingElement_type); + entity* IfcActuatorType_type = new entity("IfcActuatorType", IfcDistributionControlElementType_type); + entity* IfcAlarmType_type = new entity("IfcAlarmType", IfcDistributionControlElementType_type); + entity* IfcBeam_type = new entity("IfcBeam", IfcBuildingElement_type); + entity* IfcChamferEdgeFeature_type = new entity("IfcChamferEdgeFeature", IfcEdgeFeature_type); + entity* IfcControllerType_type = new entity("IfcControllerType", IfcDistributionControlElementType_type); + entity* IfcDistributionChamberElement_type = new entity("IfcDistributionChamberElement", IfcDistributionFlowElement_type); + entity* IfcDistributionControlElement_type = new entity("IfcDistributionControlElement", IfcDistributionElement_type); + entity* IfcElectricDistributionPoint_type = new entity("IfcElectricDistributionPoint", IfcFlowController_type); + entity* IfcReinforcingBar_type = new entity("IfcReinforcingBar", IfcReinforcingElement_type); + declaration* IfcActorSelect_type; + { + std::vector items; items.reserve(3); + items.push_back(IfcOrganization_type); + items.push_back(IfcPerson_type); + items.push_back(IfcPersonAndOrganization_type); + IfcActorSelect_type = new select_type("IfcActorSelect", items); + } + declaration* IfcAppliedValueSelect_type; + { + std::vector items; items.reserve(3); + items.push_back(IfcMeasureWithUnit_type); + items.push_back(IfcMonetaryMeasure_type); + items.push_back(IfcRatioMeasure_type); + IfcAppliedValueSelect_type = new select_type("IfcAppliedValueSelect", items); + } + declaration* IfcAxis2Placement_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcAxis2Placement2D_type); + items.push_back(IfcAxis2Placement3D_type); + IfcAxis2Placement_type = new select_type("IfcAxis2Placement", items); + } + declaration* IfcBooleanOperand_type; + { + std::vector items; items.reserve(4); + items.push_back(IfcBooleanResult_type); + items.push_back(IfcCsgPrimitive3D_type); + items.push_back(IfcHalfSpaceSolid_type); + items.push_back(IfcSolidModel_type); + IfcBooleanOperand_type = new select_type("IfcBooleanOperand", items); + } + declaration* IfcCharacterStyleSelect_type; + { + std::vector items; items.reserve(1); + items.push_back(IfcTextStyleForDefinedFont_type); + IfcCharacterStyleSelect_type = new select_type("IfcCharacterStyleSelect", items); + } + declaration* IfcClassificationNotationSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcClassificationNotation_type); + items.push_back(IfcClassificationReference_type); + IfcClassificationNotationSelect_type = new select_type("IfcClassificationNotationSelect", items); + } + declaration* IfcColour_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcColourSpecification_type); + items.push_back(IfcPreDefinedColour_type); + IfcColour_type = new select_type("IfcColour", items); + } + declaration* IfcColourOrFactor_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcColourRgb_type); + items.push_back(IfcNormalisedRatioMeasure_type); + IfcColourOrFactor_type = new select_type("IfcColourOrFactor", items); + } + declaration* IfcConditionCriterionSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcLabel_type); + items.push_back(IfcMeasureWithUnit_type); + IfcConditionCriterionSelect_type = new select_type("IfcConditionCriterionSelect", items); + } + declaration* IfcCsgSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcBooleanResult_type); + items.push_back(IfcCsgPrimitive3D_type); + IfcCsgSelect_type = new select_type("IfcCsgSelect", items); + } + declaration* IfcCurveOrEdgeCurve_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcBoundedCurve_type); + items.push_back(IfcEdgeCurve_type); + IfcCurveOrEdgeCurve_type = new select_type("IfcCurveOrEdgeCurve", items); + } + declaration* IfcCurveStyleFontSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcCurveStyleFont_type); + items.push_back(IfcPreDefinedCurveFont_type); + IfcCurveStyleFontSelect_type = new select_type("IfcCurveStyleFontSelect", items); + } + declaration* IfcDateTimeSelect_type; + { + std::vector items; items.reserve(3); + items.push_back(IfcCalendarDate_type); + items.push_back(IfcDateAndTime_type); + items.push_back(IfcLocalTime_type); + IfcDateTimeSelect_type = new select_type("IfcDateTimeSelect", items); + } + declaration* IfcDefinedSymbolSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcExternallyDefinedSymbol_type); + items.push_back(IfcPreDefinedSymbol_type); + IfcDefinedSymbolSelect_type = new select_type("IfcDefinedSymbolSelect", items); + } + declaration* IfcDerivedMeasureValue_type; + { + std::vector items; items.reserve(68); + items.push_back(IfcAbsorbedDoseMeasure_type); + items.push_back(IfcAccelerationMeasure_type); + items.push_back(IfcAngularVelocityMeasure_type); + items.push_back(IfcCompoundPlaneAngleMeasure_type); + items.push_back(IfcCurvatureMeasure_type); + items.push_back(IfcDoseEquivalentMeasure_type); + items.push_back(IfcDynamicViscosityMeasure_type); + items.push_back(IfcElectricCapacitanceMeasure_type); + items.push_back(IfcElectricChargeMeasure_type); + items.push_back(IfcElectricConductanceMeasure_type); + items.push_back(IfcElectricResistanceMeasure_type); + items.push_back(IfcElectricVoltageMeasure_type); + items.push_back(IfcEnergyMeasure_type); + items.push_back(IfcForceMeasure_type); + items.push_back(IfcFrequencyMeasure_type); + items.push_back(IfcHeatFluxDensityMeasure_type); + items.push_back(IfcHeatingValueMeasure_type); + items.push_back(IfcIlluminanceMeasure_type); + items.push_back(IfcInductanceMeasure_type); + items.push_back(IfcIntegerCountRateMeasure_type); + items.push_back(IfcIonConcentrationMeasure_type); + items.push_back(IfcIsothermalMoistureCapacityMeasure_type); + items.push_back(IfcKinematicViscosityMeasure_type); + items.push_back(IfcLinearForceMeasure_type); + items.push_back(IfcLinearMomentMeasure_type); + items.push_back(IfcLinearStiffnessMeasure_type); + items.push_back(IfcLinearVelocityMeasure_type); + items.push_back(IfcLuminousFluxMeasure_type); + items.push_back(IfcLuminousIntensityDistributionMeasure_type); + items.push_back(IfcMagneticFluxDensityMeasure_type); + items.push_back(IfcMagneticFluxMeasure_type); + items.push_back(IfcMassDensityMeasure_type); + items.push_back(IfcMassFlowRateMeasure_type); + items.push_back(IfcMassPerLengthMeasure_type); + items.push_back(IfcModulusOfElasticityMeasure_type); + items.push_back(IfcModulusOfLinearSubgradeReactionMeasure_type); + items.push_back(IfcModulusOfRotationalSubgradeReactionMeasure_type); + items.push_back(IfcModulusOfSubgradeReactionMeasure_type); + items.push_back(IfcMoistureDiffusivityMeasure_type); + items.push_back(IfcMolecularWeightMeasure_type); + items.push_back(IfcMomentOfInertiaMeasure_type); + items.push_back(IfcMonetaryMeasure_type); + items.push_back(IfcPHMeasure_type); + items.push_back(IfcPlanarForceMeasure_type); + items.push_back(IfcPowerMeasure_type); + items.push_back(IfcPressureMeasure_type); + items.push_back(IfcRadioActivityMeasure_type); + items.push_back(IfcRotationalFrequencyMeasure_type); + items.push_back(IfcRotationalMassMeasure_type); + items.push_back(IfcRotationalStiffnessMeasure_type); + items.push_back(IfcSectionModulusMeasure_type); + items.push_back(IfcSectionalAreaIntegralMeasure_type); + items.push_back(IfcShearModulusMeasure_type); + items.push_back(IfcSoundPowerMeasure_type); + items.push_back(IfcSoundPressureMeasure_type); + items.push_back(IfcSpecificHeatCapacityMeasure_type); + items.push_back(IfcTemperatureGradientMeasure_type); + items.push_back(IfcThermalAdmittanceMeasure_type); + items.push_back(IfcThermalConductivityMeasure_type); + items.push_back(IfcThermalExpansionCoefficientMeasure_type); + items.push_back(IfcThermalResistanceMeasure_type); + items.push_back(IfcThermalTransmittanceMeasure_type); + items.push_back(IfcTimeStamp_type); + items.push_back(IfcTorqueMeasure_type); + items.push_back(IfcVaporPermeabilityMeasure_type); + items.push_back(IfcVolumetricFlowRateMeasure_type); + items.push_back(IfcWarpingConstantMeasure_type); + items.push_back(IfcWarpingMomentMeasure_type); + IfcDerivedMeasureValue_type = new select_type("IfcDerivedMeasureValue", items); + } + declaration* IfcDocumentSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcDocumentInformation_type); + items.push_back(IfcDocumentReference_type); + IfcDocumentSelect_type = new select_type("IfcDocumentSelect", items); + } + declaration* IfcDraughtingCalloutElement_type; + { + std::vector items; items.reserve(3); + items.push_back(IfcAnnotationCurveOccurrence_type); + items.push_back(IfcAnnotationSymbolOccurrence_type); + items.push_back(IfcAnnotationTextOccurrence_type); + IfcDraughtingCalloutElement_type = new select_type("IfcDraughtingCalloutElement", items); + } + declaration* IfcFillAreaStyleTileShapeSelect_type; + { + std::vector items; items.reserve(1); + items.push_back(IfcFillAreaStyleTileSymbolWithStyle_type); + IfcFillAreaStyleTileShapeSelect_type = new select_type("IfcFillAreaStyleTileShapeSelect", items); + } + declaration* IfcFillStyleSelect_type; + { + std::vector items; items.reserve(4); + items.push_back(IfcColour_type); + items.push_back(IfcExternallyDefinedHatchStyle_type); + items.push_back(IfcFillAreaStyleHatching_type); + items.push_back(IfcFillAreaStyleTiles_type); + IfcFillStyleSelect_type = new select_type("IfcFillStyleSelect", items); + } + declaration* IfcGeometricSetSelect_type; + { + std::vector items; items.reserve(3); + items.push_back(IfcCurve_type); + items.push_back(IfcPoint_type); + items.push_back(IfcSurface_type); + IfcGeometricSetSelect_type = new select_type("IfcGeometricSetSelect", items); + } + declaration* IfcHatchLineDistanceSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcOneDirectionRepeatFactor_type); + items.push_back(IfcPositiveLengthMeasure_type); + IfcHatchLineDistanceSelect_type = new select_type("IfcHatchLineDistanceSelect", items); + } + declaration* IfcLayeredItem_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcRepresentation_type); + items.push_back(IfcRepresentationItem_type); + IfcLayeredItem_type = new select_type("IfcLayeredItem", items); + } + declaration* IfcLibrarySelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcLibraryInformation_type); + items.push_back(IfcLibraryReference_type); + IfcLibrarySelect_type = new select_type("IfcLibrarySelect", items); + } + declaration* IfcLightDistributionDataSourceSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcExternalReference_type); + items.push_back(IfcLightIntensityDistribution_type); + IfcLightDistributionDataSourceSelect_type = new select_type("IfcLightDistributionDataSourceSelect", items); + } + declaration* IfcMaterialSelect_type; + { + std::vector items; items.reserve(5); + items.push_back(IfcMaterial_type); + items.push_back(IfcMaterialLayer_type); + items.push_back(IfcMaterialLayerSet_type); + items.push_back(IfcMaterialLayerSetUsage_type); + items.push_back(IfcMaterialList_type); + IfcMaterialSelect_type = new select_type("IfcMaterialSelect", items); + } + declaration* IfcMeasureValue_type; + { + std::vector items; items.reserve(22); + items.push_back(IfcAmountOfSubstanceMeasure_type); + items.push_back(IfcAreaMeasure_type); + items.push_back(IfcComplexNumber_type); + items.push_back(IfcContextDependentMeasure_type); + items.push_back(IfcCountMeasure_type); + items.push_back(IfcDescriptiveMeasure_type); + items.push_back(IfcElectricCurrentMeasure_type); + items.push_back(IfcLengthMeasure_type); + items.push_back(IfcLuminousIntensityMeasure_type); + items.push_back(IfcMassMeasure_type); + items.push_back(IfcNormalisedRatioMeasure_type); + items.push_back(IfcNumericMeasure_type); + items.push_back(IfcParameterValue_type); + items.push_back(IfcPlaneAngleMeasure_type); + items.push_back(IfcPositiveLengthMeasure_type); + items.push_back(IfcPositivePlaneAngleMeasure_type); + items.push_back(IfcPositiveRatioMeasure_type); + items.push_back(IfcRatioMeasure_type); + items.push_back(IfcSolidAngleMeasure_type); + items.push_back(IfcThermodynamicTemperatureMeasure_type); + items.push_back(IfcTimeMeasure_type); + items.push_back(IfcVolumeMeasure_type); + IfcMeasureValue_type = new select_type("IfcMeasureValue", items); + } + declaration* IfcMetricValueSelect_type; + { + std::vector items; items.reserve(6); + items.push_back(IfcCostValue_type); + items.push_back(IfcDateTimeSelect_type); + items.push_back(IfcMeasureWithUnit_type); + items.push_back(IfcTable_type); + items.push_back(IfcText_type); + items.push_back(IfcTimeSeries_type); + IfcMetricValueSelect_type = new select_type("IfcMetricValueSelect", items); + } + declaration* IfcObjectReferenceSelect_type; + { + std::vector items; items.reserve(13); + items.push_back(IfcAddress_type); + items.push_back(IfcAppliedValue_type); + items.push_back(IfcCalendarDate_type); + items.push_back(IfcDateAndTime_type); + items.push_back(IfcExternalReference_type); + items.push_back(IfcLocalTime_type); + items.push_back(IfcMaterial_type); + items.push_back(IfcMaterialLayer_type); + items.push_back(IfcMaterialList_type); + items.push_back(IfcOrganization_type); + items.push_back(IfcPerson_type); + items.push_back(IfcPersonAndOrganization_type); + items.push_back(IfcTimeSeries_type); + IfcObjectReferenceSelect_type = new select_type("IfcObjectReferenceSelect", items); + } + declaration* IfcOrientationSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcDirection_type); + items.push_back(IfcPlaneAngleMeasure_type); + IfcOrientationSelect_type = new select_type("IfcOrientationSelect", items); + } + declaration* IfcPointOrVertexPoint_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcPoint_type); + items.push_back(IfcVertexPoint_type); + IfcPointOrVertexPoint_type = new select_type("IfcPointOrVertexPoint", items); + } + declaration* IfcPresentationStyleSelect_type; + { + std::vector items; items.reserve(6); + items.push_back(IfcCurveStyle_type); + items.push_back(IfcFillAreaStyle_type); + items.push_back(IfcNullStyle_type); + items.push_back(IfcSurfaceStyle_type); + items.push_back(IfcSymbolStyle_type); + items.push_back(IfcTextStyle_type); + IfcPresentationStyleSelect_type = new select_type("IfcPresentationStyleSelect", items); + } + declaration* IfcShell_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcClosedShell_type); + items.push_back(IfcOpenShell_type); + IfcShell_type = new select_type("IfcShell", items); + } + declaration* IfcSimpleValue_type; + { + std::vector items; items.reserve(7); + items.push_back(IfcBoolean_type); + items.push_back(IfcIdentifier_type); + items.push_back(IfcInteger_type); + items.push_back(IfcLabel_type); + items.push_back(IfcLogical_type); + items.push_back(IfcReal_type); + items.push_back(IfcText_type); + IfcSimpleValue_type = new select_type("IfcSimpleValue", items); + } + declaration* IfcSizeSelect_type; + { + std::vector items; items.reserve(6); + items.push_back(IfcDescriptiveMeasure_type); + items.push_back(IfcLengthMeasure_type); + items.push_back(IfcNormalisedRatioMeasure_type); + items.push_back(IfcPositiveLengthMeasure_type); + items.push_back(IfcPositiveRatioMeasure_type); + items.push_back(IfcRatioMeasure_type); + IfcSizeSelect_type = new select_type("IfcSizeSelect", items); + } + declaration* IfcSpecularHighlightSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcSpecularExponent_type); + items.push_back(IfcSpecularRoughness_type); + IfcSpecularHighlightSelect_type = new select_type("IfcSpecularHighlightSelect", items); + } + declaration* IfcStructuralActivityAssignmentSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcElement_type); + items.push_back(IfcStructuralItem_type); + IfcStructuralActivityAssignmentSelect_type = new select_type("IfcStructuralActivityAssignmentSelect", items); + } + declaration* IfcSurfaceOrFaceSurface_type; + { + std::vector items; items.reserve(3); + items.push_back(IfcFaceBasedSurfaceModel_type); + items.push_back(IfcFaceSurface_type); + items.push_back(IfcSurface_type); + IfcSurfaceOrFaceSurface_type = new select_type("IfcSurfaceOrFaceSurface", items); + } + declaration* IfcSurfaceStyleElementSelect_type; + { + std::vector items; items.reserve(5); + items.push_back(IfcExternallyDefinedSurfaceStyle_type); + items.push_back(IfcSurfaceStyleLighting_type); + items.push_back(IfcSurfaceStyleRefraction_type); + items.push_back(IfcSurfaceStyleShading_type); + items.push_back(IfcSurfaceStyleWithTextures_type); + IfcSurfaceStyleElementSelect_type = new select_type("IfcSurfaceStyleElementSelect", items); + } + declaration* IfcSymbolStyleSelect_type; + { + std::vector items; items.reserve(1); + items.push_back(IfcColour_type); + IfcSymbolStyleSelect_type = new select_type("IfcSymbolStyleSelect", items); + } + declaration* IfcTextFontSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcExternallyDefinedTextFont_type); + items.push_back(IfcPreDefinedTextFont_type); + IfcTextFontSelect_type = new select_type("IfcTextFontSelect", items); + } + declaration* IfcTextStyleSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcTextStyleTextModel_type); + items.push_back(IfcTextStyleWithBoxCharacteristics_type); + IfcTextStyleSelect_type = new select_type("IfcTextStyleSelect", items); + } + declaration* IfcTrimmingSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcCartesianPoint_type); + items.push_back(IfcParameterValue_type); + IfcTrimmingSelect_type = new select_type("IfcTrimmingSelect", items); + } + declaration* IfcUnit_type; + { + std::vector items; items.reserve(3); + items.push_back(IfcDerivedUnit_type); + items.push_back(IfcMonetaryUnit_type); + items.push_back(IfcNamedUnit_type); + IfcUnit_type = new select_type("IfcUnit", items); + } + declaration* IfcValue_type; + { + std::vector items; items.reserve(3); + items.push_back(IfcDerivedMeasureValue_type); + items.push_back(IfcMeasureValue_type); + items.push_back(IfcSimpleValue_type); + IfcValue_type = new select_type("IfcValue", items); + } + declaration* IfcVectorOrDirection_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcDirection_type); + items.push_back(IfcVector_type); + IfcVectorOrDirection_type = new select_type("IfcVectorOrDirection", items); + } + declaration* IfcCurveFontOrScaledCurveFontSelect_type; + { + std::vector items; items.reserve(2); + items.push_back(IfcCurveStyleFontAndScaling_type); + items.push_back(IfcCurveStyleFontSelect_type); + IfcCurveFontOrScaledCurveFontSelect_type = new select_type("IfcCurveFontOrScaledCurveFontSelect", items); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + Ifc2DCompositeCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RequestID", new named_type(IfcIdentifier_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcActionRequest_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("TheActor", new named_type(IfcActorSelect_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcActor_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Role", new named_type(IfcRoleEnum_type), false)); + attributes.push_back(new entity::attribute("UserDefinedRole", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcActorRole_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcActuatorTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcActuatorType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Purpose", new named_type(IfcAddressTypeEnum_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("UserDefinedPurpose", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAddress_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcAirTerminalBoxTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAirTerminalBoxType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcAirTerminalTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAirTerminalType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcAirToAirHeatRecoveryTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAirToAirHeatRecoveryType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcAlarmTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAlarmType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcAngularDimension_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAnnotation_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAnnotationCurveOccurrence_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("OuterBoundary", new named_type(IfcCurve_type), false)); + attributes.push_back(new entity::attribute("InnerBoundaries", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcCurve_type)), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcAnnotationFillArea_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("FillStyleTarget", new named_type(IfcPoint_type), true)); + attributes.push_back(new entity::attribute("GlobalOrLocal", new named_type(IfcGlobalOrLocalEnum_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAnnotationFillAreaOccurrence_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAnnotationOccurrence_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Item", new named_type(IfcGeometricRepresentationItem_type), false)); + attributes.push_back(new entity::attribute("TextureCoordinates", new named_type(IfcTextureCoordinate_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcAnnotationSurface_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAnnotationSurfaceOccurrence_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAnnotationSymbolOccurrence_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAnnotationTextOccurrence_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("ApplicationDeveloper", new named_type(IfcOrganization_type), false)); + attributes.push_back(new entity::attribute("Version", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("ApplicationFullName", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("ApplicationIdentifier", new named_type(IfcIdentifier_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcApplication_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("AppliedValue", new named_type(IfcAppliedValueSelect_type), true)); + attributes.push_back(new entity::attribute("UnitBasis", new named_type(IfcMeasureWithUnit_type), true)); + attributes.push_back(new entity::attribute("ApplicableDate", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("FixedUntilDate", new named_type(IfcDateTimeSelect_type), true)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAppliedValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("ComponentOfTotal", new named_type(IfcAppliedValue_type), false)); + attributes.push_back(new entity::attribute("Components", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcAppliedValue_type)), false)); + attributes.push_back(new entity::attribute("ArithmeticOperator", new named_type(IfcArithmeticOperatorEnum_type), false)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAppliedValueRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(7); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("ApprovalDateTime", new named_type(IfcDateTimeSelect_type), false)); + attributes.push_back(new entity::attribute("ApprovalStatus", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("ApprovalLevel", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("ApprovalQualifier", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Identifier", new named_type(IfcIdentifier_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcApproval_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Actor", new named_type(IfcActorSelect_type), false)); + attributes.push_back(new entity::attribute("Approval", new named_type(IfcApproval_type), false)); + attributes.push_back(new entity::attribute("Role", new named_type(IfcActorRole_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcApprovalActorRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ApprovedProperties", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcProperty_type)), false)); + attributes.push_back(new entity::attribute("Approval", new named_type(IfcApproval_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcApprovalPropertyRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("RelatedApproval", new named_type(IfcApproval_type), false)); + attributes.push_back(new entity::attribute("RelatingApproval", new named_type(IfcApproval_type), false)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcApprovalRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("OuterCurve", new named_type(IfcCurve_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcArbitraryClosedProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Curve", new named_type(IfcBoundedCurve_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcArbitraryOpenProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("InnerCurves", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcCurve_type)), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcArbitraryProfileDefWithVoids_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(9); + attributes.push_back(new entity::attribute("AssetID", new named_type(IfcIdentifier_type), false)); + attributes.push_back(new entity::attribute("OriginalValue", new named_type(IfcCostValue_type), false)); + attributes.push_back(new entity::attribute("CurrentValue", new named_type(IfcCostValue_type), false)); + attributes.push_back(new entity::attribute("TotalReplacementCost", new named_type(IfcCostValue_type), false)); + attributes.push_back(new entity::attribute("Owner", new named_type(IfcActorSelect_type), false)); + attributes.push_back(new entity::attribute("User", new named_type(IfcActorSelect_type), false)); + attributes.push_back(new entity::attribute("ResponsiblePerson", new named_type(IfcPerson_type), false)); + attributes.push_back(new entity::attribute("IncorporationDate", new named_type(IfcCalendarDate_type), false)); + attributes.push_back(new entity::attribute("DepreciatedValue", new named_type(IfcCostValue_type), false)); + std::vector derived; derived.reserve(14); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAsset_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("TopFlangeWidth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("TopFlangeThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("TopFlangeFilletRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("CentreOfGravityInY", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(12); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAsymmetricIShapeProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Axis", new named_type(IfcDirection_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcAxis1Placement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RefDirection", new named_type(IfcDirection_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcAxis2Placement2D_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Axis", new named_type(IfcDirection_type), true)); + attributes.push_back(new entity::attribute("RefDirection", new named_type(IfcDirection_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcAxis2Placement3D_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("Degree", new simple_type(simple_type::integer_type), false)); + attributes.push_back(new entity::attribute("ControlPointsList", new aggregation_type(aggregation_type::list_type, 2, -1, new named_type(IfcCartesianPoint_type)), false)); + attributes.push_back(new entity::attribute("CurveForm", new named_type(IfcBSplineCurveForm_type), false)); + attributes.push_back(new entity::attribute("ClosedCurve", new simple_type(simple_type::logical_type), false)); + attributes.push_back(new entity::attribute("SelfIntersect", new simple_type(simple_type::logical_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBSplineCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBeam_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcBeamTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBeamType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBezierCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RasterFormat", new named_type(IfcIdentifier_type), false)); + attributes.push_back(new entity::attribute("RasterCode", new simple_type(simple_type::boolean_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBlobTexture_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("XLength", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("YLength", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("ZLength", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBlock_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcBoilerTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBoilerType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBooleanClippingResult_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Operator", new named_type(IfcBooleanOperator_type), false)); + attributes.push_back(new entity::attribute("FirstOperand", new named_type(IfcBooleanOperand_type), false)); + attributes.push_back(new entity::attribute("SecondOperand", new named_type(IfcBooleanOperand_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBooleanResult_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcBoundaryCondition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("LinearStiffnessByLengthX", new named_type(IfcModulusOfLinearSubgradeReactionMeasure_type), true)); + attributes.push_back(new entity::attribute("LinearStiffnessByLengthY", new named_type(IfcModulusOfLinearSubgradeReactionMeasure_type), true)); + attributes.push_back(new entity::attribute("LinearStiffnessByLengthZ", new named_type(IfcModulusOfLinearSubgradeReactionMeasure_type), true)); + attributes.push_back(new entity::attribute("RotationalStiffnessByLengthX", new named_type(IfcModulusOfRotationalSubgradeReactionMeasure_type), true)); + attributes.push_back(new entity::attribute("RotationalStiffnessByLengthY", new named_type(IfcModulusOfRotationalSubgradeReactionMeasure_type), true)); + attributes.push_back(new entity::attribute("RotationalStiffnessByLengthZ", new named_type(IfcModulusOfRotationalSubgradeReactionMeasure_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBoundaryEdgeCondition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("LinearStiffnessByAreaX", new named_type(IfcModulusOfSubgradeReactionMeasure_type), true)); + attributes.push_back(new entity::attribute("LinearStiffnessByAreaY", new named_type(IfcModulusOfSubgradeReactionMeasure_type), true)); + attributes.push_back(new entity::attribute("LinearStiffnessByAreaZ", new named_type(IfcModulusOfSubgradeReactionMeasure_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBoundaryFaceCondition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("LinearStiffnessX", new named_type(IfcLinearStiffnessMeasure_type), true)); + attributes.push_back(new entity::attribute("LinearStiffnessY", new named_type(IfcLinearStiffnessMeasure_type), true)); + attributes.push_back(new entity::attribute("LinearStiffnessZ", new named_type(IfcLinearStiffnessMeasure_type), true)); + attributes.push_back(new entity::attribute("RotationalStiffnessX", new named_type(IfcRotationalStiffnessMeasure_type), true)); + attributes.push_back(new entity::attribute("RotationalStiffnessY", new named_type(IfcRotationalStiffnessMeasure_type), true)); + attributes.push_back(new entity::attribute("RotationalStiffnessZ", new named_type(IfcRotationalStiffnessMeasure_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBoundaryNodeCondition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("WarpingStiffness", new named_type(IfcWarpingMomentMeasure_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBoundaryNodeConditionWarping_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcBoundedCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcBoundedSurface_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("Corner", new named_type(IfcCartesianPoint_type), false)); + attributes.push_back(new entity::attribute("XDim", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("YDim", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("ZDim", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBoundingBox_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Enclosure", new named_type(IfcBoundingBox_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBoxedHalfSpace_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("ElevationOfRefHeight", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("ElevationOfTerrain", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("BuildingAddress", new named_type(IfcPostalAddress_type), true)); + std::vector derived; derived.reserve(12); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBuilding_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBuildingElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBuildingElementComponent_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBuildingElementPart_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("CompositionType", new named_type(IfcElementCompositionEnum_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBuildingElementProxy_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcBuildingElementProxyTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBuildingElementProxyType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBuildingElementType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Elevation", new named_type(IfcLengthMeasure_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcBuildingStorey_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("Depth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("Width", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("WallThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("Girth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("InternalFilletRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("CentreOfGravityInX", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCShapeProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCableCarrierFittingTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCableCarrierFittingType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCableCarrierSegmentTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCableCarrierSegmentType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCableSegmentTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCableSegmentType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("DayComponent", new named_type(IfcDayInMonthNumber_type), false)); + attributes.push_back(new entity::attribute("MonthComponent", new named_type(IfcMonthInYearNumber_type), false)); + attributes.push_back(new entity::attribute("YearComponent", new named_type(IfcYearNumber_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCalendarDate_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Coordinates", new aggregation_type(aggregation_type::list_type, 1, 3, new named_type(IfcLengthMeasure_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcCartesianPoint_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("Axis1", new named_type(IfcDirection_type), true)); + attributes.push_back(new entity::attribute("Axis2", new named_type(IfcDirection_type), true)); + attributes.push_back(new entity::attribute("LocalOrigin", new named_type(IfcCartesianPoint_type), false)); + attributes.push_back(new entity::attribute("Scale", new simple_type(simple_type::real_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCartesianTransformationOperator_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCartesianTransformationOperator2D_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Scale2", new simple_type(simple_type::real_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCartesianTransformationOperator2DnonUniform_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Axis3", new named_type(IfcDirection_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCartesianTransformationOperator3D_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Scale2", new simple_type(simple_type::real_type), true)); + attributes.push_back(new entity::attribute("Scale3", new simple_type(simple_type::real_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCartesianTransformationOperator3DnonUniform_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Thickness", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCenterLineProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Width", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("Height", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcChamferEdgeFeature_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcChillerTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcChillerType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Radius", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcCircle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("WallThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCircleHollowProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Radius", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCircleProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("Source", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Edition", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("EditionDate", new named_type(IfcCalendarDate_type), true)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcClassification_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Notation", new named_type(IfcClassificationNotationFacet_type), false)); + attributes.push_back(new entity::attribute("ItemOf", new named_type(IfcClassification_type), true)); + attributes.push_back(new entity::attribute("Title", new named_type(IfcLabel_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcClassificationItem_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingItem", new named_type(IfcClassificationItem_type), false)); + attributes.push_back(new entity::attribute("RelatedItems", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcClassificationItem_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcClassificationItemRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("NotationFacets", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcClassificationNotationFacet_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcClassificationNotation_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("NotationValue", new named_type(IfcLabel_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcClassificationNotationFacet_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ReferencedSource", new named_type(IfcClassification_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcClassificationReference_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcClosedShell_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCoilTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCoilType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Red", new named_type(IfcNormalisedRatioMeasure_type), false)); + attributes.push_back(new entity::attribute("Green", new named_type(IfcNormalisedRatioMeasure_type), false)); + attributes.push_back(new entity::attribute("Blue", new named_type(IfcNormalisedRatioMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcColourRgb_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcColourSpecification_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcColumn_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcColumnTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcColumnType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("UsageName", new named_type(IfcIdentifier_type), false)); + attributes.push_back(new entity::attribute("HasProperties", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcProperty_type)), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcComplexProperty_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Segments", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcCompositeCurveSegment_type)), false)); + attributes.push_back(new entity::attribute("SelfIntersect", new simple_type(simple_type::logical_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcCompositeCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Transition", new named_type(IfcTransitionCode_type), false)); + attributes.push_back(new entity::attribute("SameSense", new simple_type(simple_type::boolean_type), false)); + attributes.push_back(new entity::attribute("ParentCurve", new named_type(IfcCurve_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCompositeCurveSegment_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Profiles", new aggregation_type(aggregation_type::set_type, 2, -1, new named_type(IfcProfileDef_type)), false)); + attributes.push_back(new entity::attribute("Label", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCompositeProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCompressorTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCompressorType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCondenserTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCondenserType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCondition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Criterion", new named_type(IfcConditionCriterionSelect_type), false)); + attributes.push_back(new entity::attribute("CriterionDateTime", new named_type(IfcDateTimeSelect_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcConditionCriterion_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Position", new named_type(IfcAxis2Placement_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcConic_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("CfsFaces", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcFace_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcConnectedFaceSet_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("CurveOnRelatingElement", new named_type(IfcCurveOrEdgeCurve_type), false)); + attributes.push_back(new entity::attribute("CurveOnRelatedElement", new named_type(IfcCurveOrEdgeCurve_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcConnectionCurveGeometry_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcConnectionGeometry_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("EccentricityInX", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("EccentricityInY", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("EccentricityInZ", new named_type(IfcLengthMeasure_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcConnectionPointEccentricity_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("PointOnRelatingElement", new named_type(IfcPointOrVertexPoint_type), false)); + attributes.push_back(new entity::attribute("PointOnRelatedElement", new named_type(IfcPointOrVertexPoint_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcConnectionPointGeometry_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("LocationAtRelatingElement", new named_type(IfcAxis2Placement_type), false)); + attributes.push_back(new entity::attribute("LocationAtRelatedElement", new named_type(IfcAxis2Placement_type), true)); + attributes.push_back(new entity::attribute("ProfileOfPort", new named_type(IfcProfileDef_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcConnectionPortGeometry_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("SurfaceOnRelatingElement", new named_type(IfcSurfaceOrFaceSurface_type), false)); + attributes.push_back(new entity::attribute("SurfaceOnRelatedElement", new named_type(IfcSurfaceOrFaceSurface_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcConnectionSurfaceGeometry_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(7); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("ConstraintGrade", new named_type(IfcConstraintEnum_type), false)); + attributes.push_back(new entity::attribute("ConstraintSource", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("CreatingActor", new named_type(IfcActorSelect_type), true)); + attributes.push_back(new entity::attribute("CreationTime", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("UserDefinedGrade", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcConstraint_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("RelatingConstraint", new named_type(IfcConstraint_type), false)); + attributes.push_back(new entity::attribute("RelatedConstraints", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcConstraint_type)), false)); + attributes.push_back(new entity::attribute("LogicalAggregator", new named_type(IfcLogicalOperatorEnum_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcConstraintAggregationRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ClassifiedConstraint", new named_type(IfcConstraint_type), false)); + attributes.push_back(new entity::attribute("RelatedClassifications", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcClassificationNotationSelect_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcConstraintClassificationRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("RelatingConstraint", new named_type(IfcConstraint_type), false)); + attributes.push_back(new entity::attribute("RelatedConstraints", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcConstraint_type)), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcConstraintRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcConstructionEquipmentResource_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Suppliers", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcActorSelect_type)), true)); + attributes.push_back(new entity::attribute("UsageRatio", new named_type(IfcRatioMeasure_type), true)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcConstructionMaterialResource_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcConstructionProductResource_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("ResourceIdentifier", new named_type(IfcIdentifier_type), true)); + attributes.push_back(new entity::attribute("ResourceGroup", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("ResourceConsumption", new named_type(IfcResourceConsumptionEnum_type), true)); + attributes.push_back(new entity::attribute("BaseQuantity", new named_type(IfcMeasureWithUnit_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcConstructionResource_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcContextDependentUnit_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcControl_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcControllerTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcControllerType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("ConversionFactor", new named_type(IfcMeasureWithUnit_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcConversionBasedUnit_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCooledBeamTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCooledBeamType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCoolingTowerTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCoolingTowerType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("HourOffset", new named_type(IfcHourInDay_type), false)); + attributes.push_back(new entity::attribute("MinuteOffset", new named_type(IfcMinuteInHour_type), true)); + attributes.push_back(new entity::attribute("Sense", new named_type(IfcAheadOrBehind_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCoordinatedUniversalTimeOffset_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCostItem_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(8); + attributes.push_back(new entity::attribute("SubmittedBy", new named_type(IfcActorSelect_type), true)); + attributes.push_back(new entity::attribute("PreparedBy", new named_type(IfcActorSelect_type), true)); + attributes.push_back(new entity::attribute("SubmittedOn", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("Status", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("TargetUsers", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcActorSelect_type)), true)); + attributes.push_back(new entity::attribute("UpdateDate", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("ID", new named_type(IfcIdentifier_type), false)); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCostScheduleTypeEnum_type), false)); + std::vector derived; derived.reserve(13); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCostSchedule_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("CostType", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Condition", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCostValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCoveringTypeEnum_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCovering_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCoveringTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCoveringType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(12); + attributes.push_back(new entity::attribute("OverallHeight", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("BaseWidth2", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("Radius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("HeadWidth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("HeadDepth2", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("HeadDepth3", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("WebThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("BaseWidth4", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("BaseDepth1", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("BaseDepth2", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("BaseDepth3", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("CentreOfGravityInY", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(15); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCraneRailAShapeProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(9); + attributes.push_back(new entity::attribute("OverallHeight", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("HeadWidth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("Radius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("HeadDepth2", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("HeadDepth3", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("WebThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("BaseDepth1", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("BaseDepth2", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("CentreOfGravityInY", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(12); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCraneRailFShapeProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCrewResource_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Position", new named_type(IfcAxis2Placement3D_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcCsgPrimitive3D_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("TreeRootExpression", new named_type(IfcCsgSelect_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcCsgSolid_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("RelatingMonetaryUnit", new named_type(IfcMonetaryUnit_type), false)); + attributes.push_back(new entity::attribute("RelatedMonetaryUnit", new named_type(IfcMonetaryUnit_type), false)); + attributes.push_back(new entity::attribute("ExchangeRate", new named_type(IfcPositiveRatioMeasure_type), false)); + attributes.push_back(new entity::attribute("RateDateTime", new named_type(IfcDateAndTime_type), false)); + attributes.push_back(new entity::attribute("RateSource", new named_type(IfcLibraryInformation_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCurrencyRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCurtainWall_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcCurtainWallTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCurtainWallType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("BasisSurface", new named_type(IfcPlane_type), false)); + attributes.push_back(new entity::attribute("OuterBoundary", new named_type(IfcCurve_type), false)); + attributes.push_back(new entity::attribute("InnerBoundaries", new aggregation_type(aggregation_type::set_type, 0, -1, new named_type(IfcCurve_type)), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCurveBoundedPlane_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("CurveFont", new named_type(IfcCurveFontOrScaledCurveFontSelect_type), true)); + attributes.push_back(new entity::attribute("CurveWidth", new named_type(IfcSizeSelect_type), true)); + attributes.push_back(new entity::attribute("CurveColour", new named_type(IfcColour_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCurveStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("PatternList", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcCurveStyleFontPattern_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcCurveStyleFont_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("CurveFont", new named_type(IfcCurveStyleFontSelect_type), false)); + attributes.push_back(new entity::attribute("CurveFontScaling", new named_type(IfcPositiveRatioMeasure_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcCurveStyleFontAndScaling_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("VisibleSegmentLength", new named_type(IfcLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("InvisibleSegmentLength", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcCurveStyleFontPattern_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcDamperTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDamperType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("DateComponent", new named_type(IfcCalendarDate_type), false)); + attributes.push_back(new entity::attribute("TimeComponent", new named_type(IfcLocalTime_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcDateAndTime_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Definition", new named_type(IfcDefinedSymbolSelect_type), false)); + attributes.push_back(new entity::attribute("Target", new named_type(IfcCartesianTransformationOperator2D_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcDefinedSymbol_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("ParentProfile", new named_type(IfcProfileDef_type), false)); + attributes.push_back(new entity::attribute("Operator", new named_type(IfcCartesianTransformationOperator2D_type), false)); + attributes.push_back(new entity::attribute("Label", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDerivedProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Elements", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcDerivedUnitElement_type)), false)); + attributes.push_back(new entity::attribute("UnitType", new named_type(IfcDerivedUnitEnum_type), false)); + attributes.push_back(new entity::attribute("UserDefinedType", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDerivedUnit_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Unit", new named_type(IfcNamedUnit_type), false)); + attributes.push_back(new entity::attribute("Exponent", new simple_type(simple_type::integer_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcDerivedUnitElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcDiameterDimension_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDimensionCalloutRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDimensionCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcDimensionCurveDirectedCallout_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Role", new named_type(IfcDimensionExtentUsage_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDimensionCurveTerminator_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDimensionPair_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(7); + attributes.push_back(new entity::attribute("LengthExponent", new simple_type(simple_type::integer_type), false)); + attributes.push_back(new entity::attribute("MassExponent", new simple_type(simple_type::integer_type), false)); + attributes.push_back(new entity::attribute("TimeExponent", new simple_type(simple_type::integer_type), false)); + attributes.push_back(new entity::attribute("ElectricCurrentExponent", new simple_type(simple_type::integer_type), false)); + attributes.push_back(new entity::attribute("ThermodynamicTemperatureExponent", new simple_type(simple_type::integer_type), false)); + attributes.push_back(new entity::attribute("AmountOfSubstanceExponent", new simple_type(simple_type::integer_type), false)); + attributes.push_back(new entity::attribute("LuminousIntensityExponent", new simple_type(simple_type::integer_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDimensionalExponents_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("DirectionRatios", new aggregation_type(aggregation_type::list_type, 2, 3, new simple_type(simple_type::real_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcDirection_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDiscreteAccessory_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDiscreteAccessoryType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDistributionChamberElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcDistributionChamberElementTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDistributionChamberElementType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ControlElementId", new named_type(IfcIdentifier_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDistributionControlElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDistributionControlElementType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDistributionElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDistributionElementType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDistributionFlowElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDistributionFlowElementType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("FlowDirection", new named_type(IfcFlowDirectionEnum_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDistributionPort_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("FileExtension", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("MimeContentType", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("MimeSubtype", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDocumentElectronicFormat_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(17); + attributes.push_back(new entity::attribute("DocumentId", new named_type(IfcIdentifier_type), false)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("DocumentReferences", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcDocumentReference_type)), true)); + attributes.push_back(new entity::attribute("Purpose", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("IntendedUse", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("Scope", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("Revision", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("DocumentOwner", new named_type(IfcActorSelect_type), true)); + attributes.push_back(new entity::attribute("Editors", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcActorSelect_type)), true)); + attributes.push_back(new entity::attribute("CreationTime", new named_type(IfcDateAndTime_type), true)); + attributes.push_back(new entity::attribute("LastRevisionTime", new named_type(IfcDateAndTime_type), true)); + attributes.push_back(new entity::attribute("ElectronicFormat", new named_type(IfcDocumentElectronicFormat_type), true)); + attributes.push_back(new entity::attribute("ValidFrom", new named_type(IfcCalendarDate_type), true)); + attributes.push_back(new entity::attribute("ValidUntil", new named_type(IfcCalendarDate_type), true)); + attributes.push_back(new entity::attribute("Confidentiality", new named_type(IfcDocumentConfidentialityEnum_type), true)); + attributes.push_back(new entity::attribute("Status", new named_type(IfcDocumentStatusEnum_type), true)); + std::vector derived; derived.reserve(17); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDocumentInformation_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("RelatingDocument", new named_type(IfcDocumentInformation_type), false)); + attributes.push_back(new entity::attribute("RelatedDocuments", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcDocumentInformation_type)), false)); + attributes.push_back(new entity::attribute("RelationshipType", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDocumentInformationRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDocumentReference_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("OverallHeight", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("OverallWidth", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDoor_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(11); + attributes.push_back(new entity::attribute("LiningDepth", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("LiningThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("ThresholdDepth", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("ThresholdThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("TransomThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("TransomOffset", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("LiningOffset", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("ThresholdOffset", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("CasingThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("CasingDepth", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("ShapeAspectStyle", new named_type(IfcShapeAspect_type), true)); + std::vector derived; derived.reserve(15); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDoorLiningProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("PanelDepth", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("PanelOperation", new named_type(IfcDoorPanelOperationEnum_type), false)); + attributes.push_back(new entity::attribute("PanelWidth", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("PanelPosition", new named_type(IfcDoorPanelPositionEnum_type), false)); + attributes.push_back(new entity::attribute("ShapeAspectStyle", new named_type(IfcShapeAspect_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDoorPanelProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("OperationType", new named_type(IfcDoorStyleOperationEnum_type), false)); + attributes.push_back(new entity::attribute("ConstructionType", new named_type(IfcDoorStyleConstructionEnum_type), false)); + attributes.push_back(new entity::attribute("ParameterTakesPrecedence", new simple_type(simple_type::boolean_type), false)); + attributes.push_back(new entity::attribute("Sizeable", new simple_type(simple_type::boolean_type), false)); + std::vector derived; derived.reserve(12); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDoorStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Contents", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcDraughtingCalloutElement_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcDraughtingCallout_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("RelatingDraughtingCallout", new named_type(IfcDraughtingCallout_type), false)); + attributes.push_back(new entity::attribute("RelatedDraughtingCallout", new named_type(IfcDraughtingCallout_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDraughtingCalloutRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcDraughtingPreDefinedColour_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcDraughtingPreDefinedCurveFont_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcDraughtingPreDefinedTextFont_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcDuctFittingTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDuctFittingType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcDuctSegmentTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDuctSegmentType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcDuctSilencerTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcDuctSilencerType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("EdgeStart", new named_type(IfcVertex_type), false)); + attributes.push_back(new entity::attribute("EdgeEnd", new named_type(IfcVertex_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcEdge_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("EdgeGeometry", new named_type(IfcCurve_type), false)); + attributes.push_back(new entity::attribute("SameSense", new simple_type(simple_type::boolean_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEdgeCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("FeatureLength", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEdgeFeature_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("EdgeList", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcOrientedEdge_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcEdgeLoop_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcElectricApplianceTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElectricApplianceType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("DistributionPointFunction", new named_type(IfcElectricDistributionPointFunctionEnum_type), false)); + attributes.push_back(new entity::attribute("UserDefinedFunction", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElectricDistributionPoint_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcElectricFlowStorageDeviceTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElectricFlowStorageDeviceType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcElectricGeneratorTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElectricGeneratorType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcElectricHeaterTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElectricHeaterType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcElectricMotorTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElectricMotorType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcElectricTimeControlTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElectricTimeControlType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(8); + attributes.push_back(new entity::attribute("ElectricCurrentType", new named_type(IfcElectricCurrentEnum_type), true)); + attributes.push_back(new entity::attribute("InputVoltage", new named_type(IfcElectricVoltageMeasure_type), false)); + attributes.push_back(new entity::attribute("InputFrequency", new named_type(IfcFrequencyMeasure_type), false)); + attributes.push_back(new entity::attribute("FullLoadCurrent", new named_type(IfcElectricCurrentMeasure_type), true)); + attributes.push_back(new entity::attribute("MinimumCircuitCurrent", new named_type(IfcElectricCurrentMeasure_type), true)); + attributes.push_back(new entity::attribute("MaximumPowerInput", new named_type(IfcPowerMeasure_type), true)); + attributes.push_back(new entity::attribute("RatedPowerInput", new named_type(IfcPowerMeasure_type), true)); + attributes.push_back(new entity::attribute("InputPhase", new simple_type(simple_type::integer_type), false)); + std::vector derived; derived.reserve(14); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElectricalBaseProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElectricalCircuit_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElectricalElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Tag", new named_type(IfcIdentifier_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("AssemblyPlace", new named_type(IfcAssemblyPlaceEnum_type), true)); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcElementAssemblyTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElementAssembly_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElementComponent_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElementComponentType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("MethodOfMeasurement", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Quantities", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcPhysicalQuantity_type)), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElementQuantity_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ElementType", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcElementType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Position", new named_type(IfcAxis2Placement3D_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcElementarySurface_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("SemiAxis1", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("SemiAxis2", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEllipse_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("SemiAxis1", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("SemiAxis2", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEllipseProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEnergyConversionDevice_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEnergyConversionDeviceType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("EnergySequence", new named_type(IfcEnergySequenceEnum_type), true)); + attributes.push_back(new entity::attribute("UserDefinedEnergySequence", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEnergyProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("ImpactType", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Category", new named_type(IfcEnvironmentalImpactCategoryEnum_type), false)); + attributes.push_back(new entity::attribute("UserDefinedCategory", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEnvironmentalImpactValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEquipmentElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEquipmentStandard_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcEvaporativeCoolerTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEvaporativeCoolerType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcEvaporatorTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcEvaporatorType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("ExtendedProperties", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcProperty_type)), false)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcExtendedMaterialProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Location", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("ItemReference", new named_type(IfcIdentifier_type), true)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcExternalReference_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcExternallyDefinedHatchStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcExternallyDefinedSurfaceStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcExternallyDefinedSymbol_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcExternallyDefinedTextFont_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ExtrudedDirection", new named_type(IfcDirection_type), false)); + attributes.push_back(new entity::attribute("Depth", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcExtrudedAreaSolid_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Bounds", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcFaceBound_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcFace_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("FbsmFaces", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcConnectedFaceSet_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcFaceBasedSurfaceModel_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Bound", new named_type(IfcLoop_type), false)); + attributes.push_back(new entity::attribute("Orientation", new simple_type(simple_type::boolean_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcFaceBound_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcFaceOuterBound_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("FaceSurface", new named_type(IfcSurface_type), false)); + attributes.push_back(new entity::attribute("SameSense", new simple_type(simple_type::boolean_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFaceSurface_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcFacetedBrep_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Voids", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcClosedShell_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcFacetedBrepWithVoids_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("TensionFailureX", new named_type(IfcForceMeasure_type), true)); + attributes.push_back(new entity::attribute("TensionFailureY", new named_type(IfcForceMeasure_type), true)); + attributes.push_back(new entity::attribute("TensionFailureZ", new named_type(IfcForceMeasure_type), true)); + attributes.push_back(new entity::attribute("CompressionFailureX", new named_type(IfcForceMeasure_type), true)); + attributes.push_back(new entity::attribute("CompressionFailureY", new named_type(IfcForceMeasure_type), true)); + attributes.push_back(new entity::attribute("CompressionFailureZ", new named_type(IfcForceMeasure_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFailureConnectionCondition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcFanTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFanType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFastener_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFastenerType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFeatureElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFeatureElementAddition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFeatureElementSubtraction_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("FillStyles", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcFillStyleSelect_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcFillAreaStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("HatchLineAppearance", new named_type(IfcCurveStyle_type), false)); + attributes.push_back(new entity::attribute("StartOfNextHatchLine", new named_type(IfcHatchLineDistanceSelect_type), false)); + attributes.push_back(new entity::attribute("PointOfReferenceHatchLine", new named_type(IfcCartesianPoint_type), true)); + attributes.push_back(new entity::attribute("PatternStart", new named_type(IfcCartesianPoint_type), true)); + attributes.push_back(new entity::attribute("HatchLineAngle", new named_type(IfcPlaneAngleMeasure_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFillAreaStyleHatching_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Symbol", new named_type(IfcAnnotationSymbolOccurrence_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcFillAreaStyleTileSymbolWithStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("TilingPattern", new named_type(IfcOneDirectionRepeatFactor_type), false)); + attributes.push_back(new entity::attribute("Tiles", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcFillAreaStyleTileShapeSelect_type)), false)); + attributes.push_back(new entity::attribute("TilingScale", new named_type(IfcPositiveRatioMeasure_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFillAreaStyleTiles_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcFilterTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFilterType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcFireSuppressionTerminalTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFireSuppressionTerminalType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowController_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowControllerType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowFitting_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowFittingType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcFlowInstrumentTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowInstrumentType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcFlowMeterTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowMeterType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowMovingDevice_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowMovingDeviceType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowSegment_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowSegmentType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowStorageDevice_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowStorageDeviceType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowTerminal_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowTerminalType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowTreatmentDevice_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFlowTreatmentDeviceType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(15); + attributes.push_back(new entity::attribute("PropertySource", new named_type(IfcPropertySourceEnum_type), false)); + attributes.push_back(new entity::attribute("FlowConditionTimeSeries", new named_type(IfcTimeSeries_type), true)); + attributes.push_back(new entity::attribute("VelocityTimeSeries", new named_type(IfcTimeSeries_type), true)); + attributes.push_back(new entity::attribute("FlowrateTimeSeries", new named_type(IfcTimeSeries_type), true)); + attributes.push_back(new entity::attribute("Fluid", new named_type(IfcMaterial_type), false)); + attributes.push_back(new entity::attribute("PressureTimeSeries", new named_type(IfcTimeSeries_type), true)); + attributes.push_back(new entity::attribute("UserDefinedPropertySource", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("TemperatureSingleValue", new named_type(IfcThermodynamicTemperatureMeasure_type), true)); + attributes.push_back(new entity::attribute("WetBulbTemperatureSingleValue", new named_type(IfcThermodynamicTemperatureMeasure_type), true)); + attributes.push_back(new entity::attribute("WetBulbTemperatureTimeSeries", new named_type(IfcTimeSeries_type), true)); + attributes.push_back(new entity::attribute("TemperatureTimeSeries", new named_type(IfcTimeSeries_type), true)); + attributes.push_back(new entity::attribute("FlowrateSingleValue", new named_type(IfcDerivedMeasureValue_type), true)); + attributes.push_back(new entity::attribute("FlowConditionSingleValue", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("VelocitySingleValue", new named_type(IfcLinearVelocityMeasure_type), true)); + attributes.push_back(new entity::attribute("PressureSingleValue", new named_type(IfcPressureMeasure_type), true)); + std::vector derived; derived.reserve(19); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFluidFlowProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcFootingTypeEnum_type), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFooting_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("CombustionTemperature", new named_type(IfcThermodynamicTemperatureMeasure_type), true)); + attributes.push_back(new entity::attribute("CarbonContent", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("LowerHeatingValue", new named_type(IfcHeatingValueMeasure_type), true)); + attributes.push_back(new entity::attribute("HigherHeatingValue", new named_type(IfcHeatingValueMeasure_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFuelProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFurnishingElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFurnishingElementType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFurnitureStandard_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("AssemblyPlace", new named_type(IfcAssemblyPlaceEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcFurnitureType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcGasTerminalTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcGasTerminalType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("MolecularWeight", new named_type(IfcMolecularWeightMeasure_type), true)); + attributes.push_back(new entity::attribute("Porosity", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("MassDensity", new named_type(IfcMassDensityMeasure_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcGeneralMaterialProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("PhysicalWeight", new named_type(IfcMassPerLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("Perimeter", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("MinimumPlateThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("MaximumPlateThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("CrossSectionArea", new named_type(IfcAreaMeasure_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcGeneralProfileProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcGeometricCurveSet_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("CoordinateSpaceDimension", new named_type(IfcDimensionCount_type), false)); + attributes.push_back(new entity::attribute("Precision", new simple_type(simple_type::real_type), true)); + attributes.push_back(new entity::attribute("WorldCoordinateSystem", new named_type(IfcAxis2Placement_type), false)); + attributes.push_back(new entity::attribute("TrueNorth", new named_type(IfcDirection_type), true)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcGeometricRepresentationContext_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcGeometricRepresentationItem_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("ParentContext", new named_type(IfcGeometricRepresentationContext_type), false)); + attributes.push_back(new entity::attribute("TargetScale", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("TargetView", new named_type(IfcGeometricProjectionEnum_type), false)); + attributes.push_back(new entity::attribute("UserDefinedTargetView", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(true); derived.push_back(true); derived.push_back(true); derived.push_back(true); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcGeometricRepresentationSubContext_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Elements", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcGeometricSetSelect_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcGeometricSet_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("UAxes", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcGridAxis_type)), false)); + attributes.push_back(new entity::attribute("VAxes", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcGridAxis_type)), false)); + attributes.push_back(new entity::attribute("WAxes", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcGridAxis_type)), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcGrid_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("AxisTag", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("AxisCurve", new named_type(IfcCurve_type), false)); + attributes.push_back(new entity::attribute("SameSense", new named_type(IfcBoolean_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcGridAxis_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("PlacementLocation", new named_type(IfcVirtualGridIntersection_type), false)); + attributes.push_back(new entity::attribute("PlacementRefDirection", new named_type(IfcVirtualGridIntersection_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcGridPlacement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcGroup_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("BaseSurface", new named_type(IfcSurface_type), false)); + attributes.push_back(new entity::attribute("AgreementFlag", new simple_type(simple_type::boolean_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcHalfSpaceSolid_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcHeatExchangerTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcHeatExchangerType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcHumidifierTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcHumidifierType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("UpperVaporResistanceFactor", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("LowerVaporResistanceFactor", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("IsothermalMoistureCapacity", new named_type(IfcIsothermalMoistureCapacityMeasure_type), true)); + attributes.push_back(new entity::attribute("VaporPermeability", new named_type(IfcVaporPermeabilityMeasure_type), true)); + attributes.push_back(new entity::attribute("MoistureDiffusivity", new named_type(IfcMoistureDiffusivityMeasure_type), true)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcHygroscopicMaterialProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("OverallWidth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("OverallDepth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("WebThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FlangeThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FilletRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcIShapeProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("UrlReference", new named_type(IfcIdentifier_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcImageTexture_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("InventoryType", new named_type(IfcInventoryTypeEnum_type), false)); + attributes.push_back(new entity::attribute("Jurisdiction", new named_type(IfcActorSelect_type), false)); + attributes.push_back(new entity::attribute("ResponsiblePersons", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcPerson_type)), false)); + attributes.push_back(new entity::attribute("LastUpdateDate", new named_type(IfcCalendarDate_type), false)); + attributes.push_back(new entity::attribute("CurrentValue", new named_type(IfcCostValue_type), true)); + attributes.push_back(new entity::attribute("OriginalValue", new named_type(IfcCostValue_type), true)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcInventory_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Values", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcIrregularTimeSeriesValue_type)), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcIrregularTimeSeries_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("TimeStamp", new named_type(IfcDateTimeSelect_type), false)); + attributes.push_back(new entity::attribute("ListValues", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcValue_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcIrregularTimeSeriesValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcJunctionBoxTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcJunctionBoxType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(8); + attributes.push_back(new entity::attribute("Depth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("Width", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("Thickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FilletRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("EdgeRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("LegSlope", new named_type(IfcPlaneAngleMeasure_type), true)); + attributes.push_back(new entity::attribute("CentreOfGravityInX", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("CentreOfGravityInY", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLShapeProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("SkillSet", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLaborResource_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcLampTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLampType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Version", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Publisher", new named_type(IfcOrganization_type), true)); + attributes.push_back(new entity::attribute("VersionDate", new named_type(IfcCalendarDate_type), true)); + attributes.push_back(new entity::attribute("LibraryReference", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcLibraryReference_type)), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLibraryInformation_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLibraryReference_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("MainPlaneAngle", new named_type(IfcPlaneAngleMeasure_type), false)); + attributes.push_back(new entity::attribute("SecondaryPlaneAngle", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcPlaneAngleMeasure_type)), false)); + attributes.push_back(new entity::attribute("LuminousIntensity", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcLuminousIntensityDistributionMeasure_type)), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLightDistributionData_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcLightFixtureTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLightFixtureType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("LightDistributionCurve", new named_type(IfcLightDistributionCurveEnum_type), false)); + attributes.push_back(new entity::attribute("DistributionData", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcLightDistributionData_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcLightIntensityDistribution_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("LightColour", new named_type(IfcColourRgb_type), false)); + attributes.push_back(new entity::attribute("AmbientIntensity", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("Intensity", new named_type(IfcNormalisedRatioMeasure_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLightSource_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLightSourceAmbient_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Orientation", new named_type(IfcDirection_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLightSourceDirectional_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("Position", new named_type(IfcAxis2Placement3D_type), false)); + attributes.push_back(new entity::attribute("ColourAppearance", new named_type(IfcColourRgb_type), true)); + attributes.push_back(new entity::attribute("ColourTemperature", new named_type(IfcThermodynamicTemperatureMeasure_type), false)); + attributes.push_back(new entity::attribute("LuminousFlux", new named_type(IfcLuminousFluxMeasure_type), false)); + attributes.push_back(new entity::attribute("LightEmissionSource", new named_type(IfcLightEmissionSourceEnum_type), false)); + attributes.push_back(new entity::attribute("LightDistributionDataSource", new named_type(IfcLightDistributionDataSourceSelect_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLightSourceGoniometric_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("Position", new named_type(IfcCartesianPoint_type), false)); + attributes.push_back(new entity::attribute("Radius", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("ConstantAttenuation", new named_type(IfcReal_type), false)); + attributes.push_back(new entity::attribute("DistanceAttenuation", new named_type(IfcReal_type), false)); + attributes.push_back(new entity::attribute("QuadricAttenuation", new named_type(IfcReal_type), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLightSourcePositional_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("Orientation", new named_type(IfcDirection_type), false)); + attributes.push_back(new entity::attribute("ConcentrationExponent", new named_type(IfcReal_type), true)); + attributes.push_back(new entity::attribute("SpreadAngle", new named_type(IfcPositivePlaneAngleMeasure_type), false)); + attributes.push_back(new entity::attribute("BeamWidthAngle", new named_type(IfcPositivePlaneAngleMeasure_type), false)); + std::vector derived; derived.reserve(13); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLightSourceSpot_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Pnt", new named_type(IfcCartesianPoint_type), false)); + attributes.push_back(new entity::attribute("Dir", new named_type(IfcVector_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcLine_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcLinearDimension_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("PlacementRelTo", new named_type(IfcObjectPlacement_type), true)); + attributes.push_back(new entity::attribute("RelativePlacement", new named_type(IfcAxis2Placement_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcLocalPlacement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("HourComponent", new named_type(IfcHourInDay_type), false)); + attributes.push_back(new entity::attribute("MinuteComponent", new named_type(IfcMinuteInHour_type), true)); + attributes.push_back(new entity::attribute("SecondComponent", new named_type(IfcSecondInMinute_type), true)); + attributes.push_back(new entity::attribute("Zone", new named_type(IfcCoordinatedUniversalTimeOffset_type), true)); + attributes.push_back(new entity::attribute("DaylightSavingOffset", new named_type(IfcDaylightSavingHour_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcLocalTime_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcLoop_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Outer", new named_type(IfcClosedShell_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcManifoldSolidBrep_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("MappingSource", new named_type(IfcRepresentationMap_type), false)); + attributes.push_back(new entity::attribute("MappingTarget", new named_type(IfcCartesianTransformationOperator_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcMappedItem_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcMaterial_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("MaterialClassifications", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcClassificationNotationSelect_type)), false)); + attributes.push_back(new entity::attribute("ClassifiedMaterial", new named_type(IfcMaterial_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcMaterialClassificationRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RepresentedMaterial", new named_type(IfcMaterial_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMaterialDefinitionRepresentation_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Material", new named_type(IfcMaterial_type), true)); + attributes.push_back(new entity::attribute("LayerThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("IsVentilated", new named_type(IfcLogical_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMaterialLayer_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("MaterialLayers", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcMaterialLayer_type)), false)); + attributes.push_back(new entity::attribute("LayerSetName", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcMaterialLayerSet_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("ForLayerSet", new named_type(IfcMaterialLayerSet_type), false)); + attributes.push_back(new entity::attribute("LayerSetDirection", new named_type(IfcLayerSetDirectionEnum_type), false)); + attributes.push_back(new entity::attribute("DirectionSense", new named_type(IfcDirectionSenseEnum_type), false)); + attributes.push_back(new entity::attribute("OffsetFromReferenceLine", new named_type(IfcLengthMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMaterialLayerSetUsage_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Materials", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcMaterial_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcMaterialList_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Material", new named_type(IfcMaterial_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcMaterialProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ValueComponent", new named_type(IfcValue_type), false)); + attributes.push_back(new entity::attribute("UnitComponent", new named_type(IfcUnit_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcMeasureWithUnit_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("CompressiveStrength", new named_type(IfcPressureMeasure_type), true)); + attributes.push_back(new entity::attribute("MaxAggregateSize", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("AdmixturesDescription", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("Workability", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("ProtectivePoreRatio", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("WaterImpermeability", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(12); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMechanicalConcreteMaterialProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("NominalDiameter", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("NominalLength", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMechanicalFastener_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMechanicalFastenerType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("DynamicViscosity", new named_type(IfcDynamicViscosityMeasure_type), true)); + attributes.push_back(new entity::attribute("YoungModulus", new named_type(IfcModulusOfElasticityMeasure_type), true)); + attributes.push_back(new entity::attribute("ShearModulus", new named_type(IfcModulusOfElasticityMeasure_type), true)); + attributes.push_back(new entity::attribute("PoissonRatio", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("ThermalExpansionCoefficient", new named_type(IfcThermalExpansionCoefficientMeasure_type), true)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMechanicalMaterialProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(7); + attributes.push_back(new entity::attribute("YieldStress", new named_type(IfcPressureMeasure_type), true)); + attributes.push_back(new entity::attribute("UltimateStress", new named_type(IfcPressureMeasure_type), true)); + attributes.push_back(new entity::attribute("UltimateStrain", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("HardeningModule", new named_type(IfcModulusOfElasticityMeasure_type), true)); + attributes.push_back(new entity::attribute("ProportionalStress", new named_type(IfcPressureMeasure_type), true)); + attributes.push_back(new entity::attribute("PlasticStrain", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("Relaxations", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcRelaxation_type)), true)); + std::vector derived; derived.reserve(13); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMechanicalSteelMaterialProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMember_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcMemberTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMemberType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Benchmark", new named_type(IfcBenchmarkEnum_type), false)); + attributes.push_back(new entity::attribute("ValueSource", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("DataValue", new named_type(IfcMetricValueSelect_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMetric_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Currency", new named_type(IfcCurrencyEnum_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcMonetaryUnit_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcMotorConnectionTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMotorConnectionType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("MoveFrom", new named_type(IfcSpatialStructureElement_type), false)); + attributes.push_back(new entity::attribute("MoveTo", new named_type(IfcSpatialStructureElement_type), false)); + attributes.push_back(new entity::attribute("PunchList", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcText_type)), true)); + std::vector derived; derived.reserve(13); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcMove_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Dimensions", new named_type(IfcDimensionalExponents_type), false)); + attributes.push_back(new entity::attribute("UnitType", new named_type(IfcUnitEnum_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcNamedUnit_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ObjectType", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcObject_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcObjectDefinition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcObjectPlacement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("BenchmarkValues", new named_type(IfcMetric_type), true)); + attributes.push_back(new entity::attribute("ResultValues", new named_type(IfcMetric_type), true)); + attributes.push_back(new entity::attribute("ObjectiveQualifier", new named_type(IfcObjectiveEnum_type), false)); + attributes.push_back(new entity::attribute("UserDefinedQualifier", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcObjective_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcOccupantTypeEnum_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcOccupant_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("BasisCurve", new named_type(IfcCurve_type), false)); + attributes.push_back(new entity::attribute("Distance", new named_type(IfcLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("SelfIntersect", new simple_type(simple_type::logical_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcOffsetCurve2D_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("BasisCurve", new named_type(IfcCurve_type), false)); + attributes.push_back(new entity::attribute("Distance", new named_type(IfcLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("SelfIntersect", new simple_type(simple_type::logical_type), false)); + attributes.push_back(new entity::attribute("RefDirection", new named_type(IfcDirection_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcOffsetCurve3D_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RepeatFactor", new named_type(IfcVector_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcOneDirectionRepeatFactor_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcOpenShell_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcOpeningElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(9); + attributes.push_back(new entity::attribute("VisibleTransmittance", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("SolarTransmittance", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("ThermalIrTransmittance", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("ThermalIrEmissivityBack", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("ThermalIrEmissivityFront", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("VisibleReflectanceBack", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("VisibleReflectanceFront", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("SolarReflectanceFront", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("SolarReflectanceBack", new named_type(IfcPositiveRatioMeasure_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcOpticalMaterialProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ActionID", new named_type(IfcIdentifier_type), false)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcOrderAction_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("Id", new named_type(IfcIdentifier_type), true)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("Roles", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcActorRole_type)), true)); + attributes.push_back(new entity::attribute("Addresses", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcAddress_type)), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcOrganization_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("RelatingOrganization", new named_type(IfcOrganization_type), false)); + attributes.push_back(new entity::attribute("RelatedOrganizations", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcOrganization_type)), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcOrganizationRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("EdgeElement", new named_type(IfcEdge_type), false)); + attributes.push_back(new entity::attribute("Orientation", new simple_type(simple_type::boolean_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(true); derived.push_back(true); derived.push_back(false); derived.push_back(false); + IfcOrientedEdge_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcOutletTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcOutletType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(8); + attributes.push_back(new entity::attribute("OwningUser", new named_type(IfcPersonAndOrganization_type), false)); + attributes.push_back(new entity::attribute("OwningApplication", new named_type(IfcApplication_type), false)); + attributes.push_back(new entity::attribute("State", new named_type(IfcStateEnum_type), true)); + attributes.push_back(new entity::attribute("ChangeAction", new named_type(IfcChangeActionEnum_type), false)); + attributes.push_back(new entity::attribute("LastModifiedDate", new named_type(IfcTimeStamp_type), true)); + attributes.push_back(new entity::attribute("LastModifyingUser", new named_type(IfcPersonAndOrganization_type), true)); + attributes.push_back(new entity::attribute("LastModifyingApplication", new named_type(IfcApplication_type), true)); + attributes.push_back(new entity::attribute("CreationDate", new named_type(IfcTimeStamp_type), false)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcOwnerHistory_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Position", new named_type(IfcAxis2Placement2D_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcParameterizedProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("EdgeList", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcOrientedEdge_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPath_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("LifeCyclePhase", new named_type(IfcLabel_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPerformanceHistory_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("OperationType", new named_type(IfcPermeableCoveringOperationEnum_type), false)); + attributes.push_back(new entity::attribute("PanelPosition", new named_type(IfcWindowPanelPositionEnum_type), false)); + attributes.push_back(new entity::attribute("FrameDepth", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("FrameThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("ShapeAspectStyle", new named_type(IfcShapeAspect_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPermeableCoveringProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PermitID", new named_type(IfcIdentifier_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPermit_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(8); + attributes.push_back(new entity::attribute("Id", new named_type(IfcIdentifier_type), true)); + attributes.push_back(new entity::attribute("FamilyName", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("GivenName", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("MiddleNames", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcLabel_type)), true)); + attributes.push_back(new entity::attribute("PrefixTitles", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcLabel_type)), true)); + attributes.push_back(new entity::attribute("SuffixTitles", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcLabel_type)), true)); + attributes.push_back(new entity::attribute("Roles", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcActorRole_type)), true)); + attributes.push_back(new entity::attribute("Addresses", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcAddress_type)), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPerson_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("ThePerson", new named_type(IfcPerson_type), false)); + attributes.push_back(new entity::attribute("TheOrganization", new named_type(IfcOrganization_type), false)); + attributes.push_back(new entity::attribute("Roles", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcActorRole_type)), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPersonAndOrganization_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("HasQuantities", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcPhysicalQuantity_type)), false)); + attributes.push_back(new entity::attribute("Discrimination", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Quality", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Usage", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPhysicalComplexQuantity_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcPhysicalQuantity_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Unit", new named_type(IfcNamedUnit_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPhysicalSimpleQuantity_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcPileTypeEnum_type), false)); + attributes.push_back(new entity::attribute("ConstructionType", new named_type(IfcPileConstructionEnum_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPile_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcPipeFittingTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPipeFittingType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcPipeSegmentTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPipeSegmentType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("Width", new named_type(IfcInteger_type), false)); + attributes.push_back(new entity::attribute("Height", new named_type(IfcInteger_type), false)); + attributes.push_back(new entity::attribute("ColourComponents", new named_type(IfcInteger_type), false)); + attributes.push_back(new entity::attribute("Pixel", new aggregation_type(aggregation_type::list_type, 1, -1, new simple_type(simple_type::binary_type)), false)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPixelTexture_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Location", new named_type(IfcCartesianPoint_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPlacement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Placement", new named_type(IfcAxis2Placement_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPlanarBox_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("SizeInX", new named_type(IfcLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("SizeInY", new named_type(IfcLengthMeasure_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcPlanarExtent_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPlane_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPlate_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcPlateTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPlateType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcPoint_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("BasisCurve", new named_type(IfcCurve_type), false)); + attributes.push_back(new entity::attribute("PointParameter", new named_type(IfcParameterValue_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcPointOnCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("BasisSurface", new named_type(IfcSurface_type), false)); + attributes.push_back(new entity::attribute("PointParameterU", new named_type(IfcParameterValue_type), false)); + attributes.push_back(new entity::attribute("PointParameterV", new named_type(IfcParameterValue_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPointOnSurface_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Polygon", new aggregation_type(aggregation_type::list_type, 3, -1, new named_type(IfcCartesianPoint_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPolyLoop_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Position", new named_type(IfcAxis2Placement3D_type), false)); + attributes.push_back(new entity::attribute("PolygonalBoundary", new named_type(IfcBoundedCurve_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPolygonalBoundedHalfSpace_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Points", new aggregation_type(aggregation_type::list_type, 2, -1, new named_type(IfcCartesianPoint_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPolyline_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPort_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(7); + attributes.push_back(new entity::attribute("InternalLocation", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("AddressLines", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcLabel_type)), true)); + attributes.push_back(new entity::attribute("PostalBox", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Town", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Region", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("PostalCode", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Country", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPostalAddress_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPreDefinedColour_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPreDefinedCurveFont_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPreDefinedDimensionSymbol_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPreDefinedItem_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPreDefinedPointMarkerSymbol_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPreDefinedSymbol_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPreDefinedTerminatorSymbol_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPreDefinedTextFont_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("AssignedItems", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcLayeredItem_type)), false)); + attributes.push_back(new entity::attribute("Identifier", new named_type(IfcIdentifier_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPresentationLayerAssignment_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("LayerOn", new simple_type(simple_type::logical_type), false)); + attributes.push_back(new entity::attribute("LayerFrozen", new simple_type(simple_type::logical_type), false)); + attributes.push_back(new entity::attribute("LayerBlocked", new simple_type(simple_type::logical_type), false)); + attributes.push_back(new entity::attribute("LayerStyles", new aggregation_type(aggregation_type::set_type, 0, -1, new named_type(IfcPresentationStyleSelect_type)), false)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPresentationLayerWithStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPresentationStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Styles", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcPresentationStyleSelect_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcPresentationStyleAssignment_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("ProcedureID", new named_type(IfcIdentifier_type), false)); + attributes.push_back(new entity::attribute("ProcedureType", new named_type(IfcProcedureTypeEnum_type), false)); + attributes.push_back(new entity::attribute("UserDefinedProcedureType", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProcedure_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProcess_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ObjectPlacement", new named_type(IfcObjectPlacement_type), true)); + attributes.push_back(new entity::attribute("Representation", new named_type(IfcProductRepresentation_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProduct_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProductDefinitionShape_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("Representations", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcRepresentation_type)), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProductRepresentation_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("SpecificHeatCapacity", new named_type(IfcSpecificHeatCapacityMeasure_type), true)); + attributes.push_back(new entity::attribute("N20Content", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("COContent", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("CO2Content", new named_type(IfcPositiveRatioMeasure_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProductsOfCombustionProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ProfileType", new named_type(IfcProfileTypeEnum_type), false)); + attributes.push_back(new entity::attribute("ProfileName", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ProfileName", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("ProfileDefinition", new named_type(IfcProfileDef_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcProfileProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("LongName", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Phase", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("RepresentationContexts", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcRepresentationContext_type)), false)); + attributes.push_back(new entity::attribute("UnitsInContext", new named_type(IfcUnitAssignment_type), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProject_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("ID", new named_type(IfcIdentifier_type), false)); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcProjectOrderTypeEnum_type), false)); + attributes.push_back(new entity::attribute("Status", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProjectOrder_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Records", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcRelAssignsToProjectOrder_type)), false)); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcProjectOrderRecordTypeEnum_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProjectOrderRecord_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProjectionCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProjectionElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Name", new named_type(IfcIdentifier_type), false)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcProperty_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("UpperBoundValue", new named_type(IfcValue_type), true)); + attributes.push_back(new entity::attribute("LowerBoundValue", new named_type(IfcValue_type), true)); + attributes.push_back(new entity::attribute("Unit", new named_type(IfcUnit_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertyBoundedValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("RelatingConstraint", new named_type(IfcConstraint_type), false)); + attributes.push_back(new entity::attribute("RelatedProperties", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcProperty_type)), false)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertyConstraintRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertyDefinition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("DependingProperty", new named_type(IfcProperty_type), false)); + attributes.push_back(new entity::attribute("DependantProperty", new named_type(IfcProperty_type), false)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("Expression", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertyDependencyRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("EnumerationValues", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcValue_type)), false)); + attributes.push_back(new entity::attribute("EnumerationReference", new named_type(IfcPropertyEnumeration_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertyEnumeratedValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("EnumerationValues", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcValue_type)), false)); + attributes.push_back(new entity::attribute("Unit", new named_type(IfcUnit_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertyEnumeration_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ListValues", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcValue_type)), false)); + attributes.push_back(new entity::attribute("Unit", new named_type(IfcUnit_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertyListValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("UsageName", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("PropertyReference", new named_type(IfcObjectReferenceSelect_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertyReferenceValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("HasProperties", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcProperty_type)), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertySet_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertySetDefinition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("NominalValue", new named_type(IfcValue_type), true)); + attributes.push_back(new entity::attribute("Unit", new named_type(IfcUnit_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertySingleValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("DefiningValues", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcValue_type)), false)); + attributes.push_back(new entity::attribute("DefinedValues", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcValue_type)), false)); + attributes.push_back(new entity::attribute("Expression", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("DefiningUnit", new named_type(IfcUnit_type), true)); + attributes.push_back(new entity::attribute("DefinedUnit", new named_type(IfcUnit_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPropertyTableValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcProtectiveDeviceTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProtectiveDeviceType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ProxyType", new named_type(IfcObjectTypeEnum_type), false)); + attributes.push_back(new entity::attribute("Tag", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcProxy_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcPumpTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcPumpType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("AreaValue", new named_type(IfcAreaMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcQuantityArea_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("CountValue", new named_type(IfcCountMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcQuantityCount_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("LengthValue", new named_type(IfcLengthMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcQuantityLength_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("TimeValue", new named_type(IfcTimeMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcQuantityTime_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("VolumeValue", new named_type(IfcVolumeMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcQuantityVolume_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("WeightValue", new named_type(IfcMassMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcQuantityWeight_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcRadiusDimension_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcRailingTypeEnum_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRailing_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcRailingTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRailingType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ShapeType", new named_type(IfcRampTypeEnum_type), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRamp_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRampFlight_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcRampFlightTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRampFlightType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("WeightsData", new aggregation_type(aggregation_type::list_type, 2, -1, new simple_type(simple_type::real_type)), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRationalBezierCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("WallThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("InnerFilletRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("OuterFilletRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRectangleHollowProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("XDim", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("YDim", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRectangleProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("XLength", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("YLength", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("Height", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRectangularPyramid_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(7); + attributes.push_back(new entity::attribute("BasisSurface", new named_type(IfcSurface_type), false)); + attributes.push_back(new entity::attribute("U1", new named_type(IfcParameterValue_type), false)); + attributes.push_back(new entity::attribute("V1", new named_type(IfcParameterValue_type), false)); + attributes.push_back(new entity::attribute("U2", new named_type(IfcParameterValue_type), false)); + attributes.push_back(new entity::attribute("V2", new named_type(IfcParameterValue_type), false)); + attributes.push_back(new entity::attribute("Usense", new simple_type(simple_type::boolean_type), false)); + attributes.push_back(new entity::attribute("Vsense", new simple_type(simple_type::boolean_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRectangularTrimmedSurface_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("ReferencedDocument", new named_type(IfcDocumentSelect_type), false)); + attributes.push_back(new entity::attribute("ReferencingValues", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcAppliedValue_type)), false)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcReferencesValueDocument_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("TimeStep", new named_type(IfcTimeMeasure_type), false)); + attributes.push_back(new entity::attribute("Values", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcTimeSeriesValue_type)), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRegularTimeSeries_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("TotalCrossSectionArea", new named_type(IfcAreaMeasure_type), false)); + attributes.push_back(new entity::attribute("SteelGrade", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("BarSurface", new named_type(IfcReinforcingBarSurfaceEnum_type), true)); + attributes.push_back(new entity::attribute("EffectiveDepth", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("NominalBarDiameter", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("BarCount", new named_type(IfcCountMeasure_type), true)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcReinforcementBarProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("DefinitionType", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("ReinforcementSectionDefinitions", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcSectionReinforcementProperties_type)), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcReinforcementDefinitionProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("NominalDiameter", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("CrossSectionArea", new named_type(IfcAreaMeasure_type), false)); + attributes.push_back(new entity::attribute("BarLength", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("BarRole", new named_type(IfcReinforcingBarRoleEnum_type), false)); + attributes.push_back(new entity::attribute("BarSurface", new named_type(IfcReinforcingBarSurfaceEnum_type), true)); + std::vector derived; derived.reserve(14); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcReinforcingBar_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("SteelGrade", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcReinforcingElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(8); + attributes.push_back(new entity::attribute("MeshLength", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("MeshWidth", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("LongitudinalBarNominalDiameter", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("TransverseBarNominalDiameter", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("LongitudinalBarCrossSectionArea", new named_type(IfcAreaMeasure_type), false)); + attributes.push_back(new entity::attribute("TransverseBarCrossSectionArea", new named_type(IfcAreaMeasure_type), false)); + attributes.push_back(new entity::attribute("LongitudinalBarSpacing", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("TransverseBarSpacing", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(17); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcReinforcingMesh_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAggregates_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatedObjects", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcObjectDefinition_type)), false)); + attributes.push_back(new entity::attribute("RelatedObjectsType", new named_type(IfcObjectTypeEnum_type), true)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssigns_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("TimeForTask", new named_type(IfcScheduleTimeControl_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssignsTasks_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingActor", new named_type(IfcActor_type), false)); + attributes.push_back(new entity::attribute("ActingRole", new named_type(IfcActorRole_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssignsToActor_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingControl", new named_type(IfcControl_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssignsToControl_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingGroup", new named_type(IfcGroup_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssignsToGroup_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingProcess", new named_type(IfcProcess_type), false)); + attributes.push_back(new entity::attribute("QuantityInProcess", new named_type(IfcMeasureWithUnit_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssignsToProcess_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingProduct", new named_type(IfcProduct_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssignsToProduct_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssignsToProjectOrder_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingResource", new named_type(IfcResource_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssignsToResource_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatedObjects", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcRoot_type)), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssociates_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingAppliedValue", new named_type(IfcAppliedValue_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssociatesAppliedValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingApproval", new named_type(IfcApproval_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssociatesApproval_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingClassification", new named_type(IfcClassificationNotationSelect_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssociatesClassification_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Intent", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("RelatingConstraint", new named_type(IfcConstraint_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssociatesConstraint_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingDocument", new named_type(IfcDocumentSelect_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssociatesDocument_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingLibrary", new named_type(IfcLibrarySelect_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssociatesLibrary_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingMaterial", new named_type(IfcMaterialSelect_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssociatesMaterial_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("RelatingProfileProperties", new named_type(IfcProfileProperties_type), false)); + attributes.push_back(new entity::attribute("ProfileSectionLocation", new named_type(IfcShapeAspect_type), true)); + attributes.push_back(new entity::attribute("ProfileOrientation", new named_type(IfcOrientationSelect_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelAssociatesProfileProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelConnects_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("ConnectionGeometry", new named_type(IfcConnectionGeometry_type), true)); + attributes.push_back(new entity::attribute("RelatingElement", new named_type(IfcElement_type), false)); + attributes.push_back(new entity::attribute("RelatedElement", new named_type(IfcElement_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelConnectsElements_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("RelatingPriorities", new aggregation_type(aggregation_type::list_type, 0, -1, new simple_type(simple_type::integer_type)), false)); + attributes.push_back(new entity::attribute("RelatedPriorities", new aggregation_type(aggregation_type::list_type, 0, -1, new simple_type(simple_type::integer_type)), false)); + attributes.push_back(new entity::attribute("RelatedConnectionType", new named_type(IfcConnectionTypeEnum_type), false)); + attributes.push_back(new entity::attribute("RelatingConnectionType", new named_type(IfcConnectionTypeEnum_type), false)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelConnectsPathElements_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingPort", new named_type(IfcPort_type), false)); + attributes.push_back(new entity::attribute("RelatedElement", new named_type(IfcElement_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelConnectsPortToElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("RelatingPort", new named_type(IfcPort_type), false)); + attributes.push_back(new entity::attribute("RelatedPort", new named_type(IfcPort_type), false)); + attributes.push_back(new entity::attribute("RealizingElement", new named_type(IfcElement_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelConnectsPorts_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingElement", new named_type(IfcStructuralActivityAssignmentSelect_type), false)); + attributes.push_back(new entity::attribute("RelatedStructuralActivity", new named_type(IfcStructuralActivity_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelConnectsStructuralActivity_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingElement", new named_type(IfcElement_type), false)); + attributes.push_back(new entity::attribute("RelatedStructuralMember", new named_type(IfcStructuralMember_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelConnectsStructuralElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("RelatingStructuralMember", new named_type(IfcStructuralMember_type), false)); + attributes.push_back(new entity::attribute("RelatedStructuralConnection", new named_type(IfcStructuralConnection_type), false)); + attributes.push_back(new entity::attribute("AppliedCondition", new named_type(IfcBoundaryCondition_type), true)); + attributes.push_back(new entity::attribute("AdditionalConditions", new named_type(IfcStructuralConnectionCondition_type), true)); + attributes.push_back(new entity::attribute("SupportedLength", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("ConditionCoordinateSystem", new named_type(IfcAxis2Placement3D_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelConnectsStructuralMember_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ConnectionConstraint", new named_type(IfcConnectionGeometry_type), false)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelConnectsWithEccentricity_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RealizingElements", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcElement_type)), false)); + attributes.push_back(new entity::attribute("ConnectionType", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelConnectsWithRealizingElements_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatedElements", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcProduct_type)), false)); + attributes.push_back(new entity::attribute("RelatingStructure", new named_type(IfcSpatialStructureElement_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelContainedInSpatialStructure_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingBuildingElement", new named_type(IfcElement_type), false)); + attributes.push_back(new entity::attribute("RelatedCoverings", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcCovering_type)), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelCoversBldgElements_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatedSpace", new named_type(IfcSpace_type), false)); + attributes.push_back(new entity::attribute("RelatedCoverings", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcCovering_type)), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelCoversSpaces_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingObject", new named_type(IfcObjectDefinition_type), false)); + attributes.push_back(new entity::attribute("RelatedObjects", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcObjectDefinition_type)), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelDecomposes_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatedObjects", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcObject_type)), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelDefines_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingPropertyDefinition", new named_type(IfcPropertySetDefinition_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelDefinesByProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RelatingType", new named_type(IfcTypeObject_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelDefinesByType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingOpeningElement", new named_type(IfcOpeningElement_type), false)); + attributes.push_back(new entity::attribute("RelatedBuildingElement", new named_type(IfcElement_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelFillsElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatedControlElements", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcDistributionControlElement_type)), false)); + attributes.push_back(new entity::attribute("RelatingFlowElement", new named_type(IfcDistributionFlowElement_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelFlowControlElements_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("DailyInteraction", new named_type(IfcCountMeasure_type), true)); + attributes.push_back(new entity::attribute("ImportanceRating", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("LocationOfInteraction", new named_type(IfcSpatialStructureElement_type), true)); + attributes.push_back(new entity::attribute("RelatedSpaceProgram", new named_type(IfcSpaceProgram_type), false)); + attributes.push_back(new entity::attribute("RelatingSpaceProgram", new named_type(IfcSpaceProgram_type), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelInteractionRequirements_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelNests_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelOccupiesSpaces_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("OverridingProperties", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcProperty_type)), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelOverridesProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingElement", new named_type(IfcElement_type), false)); + attributes.push_back(new entity::attribute("RelatedFeatureElement", new named_type(IfcFeatureElementAddition_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelProjectsElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatedElements", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcProduct_type)), false)); + attributes.push_back(new entity::attribute("RelatingStructure", new named_type(IfcSpatialStructureElement_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelReferencedInSpatialStructure_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelSchedulesCostItems_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("RelatingProcess", new named_type(IfcProcess_type), false)); + attributes.push_back(new entity::attribute("RelatedProcess", new named_type(IfcProcess_type), false)); + attributes.push_back(new entity::attribute("TimeLag", new named_type(IfcTimeMeasure_type), false)); + attributes.push_back(new entity::attribute("SequenceType", new named_type(IfcSequenceEnum_type), false)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelSequence_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingSystem", new named_type(IfcSystem_type), false)); + attributes.push_back(new entity::attribute("RelatedBuildings", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcSpatialStructureElement_type)), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelServicesBuildings_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("RelatingSpace", new named_type(IfcSpace_type), false)); + attributes.push_back(new entity::attribute("RelatedBuildingElement", new named_type(IfcElement_type), true)); + attributes.push_back(new entity::attribute("ConnectionGeometry", new named_type(IfcConnectionGeometry_type), true)); + attributes.push_back(new entity::attribute("PhysicalOrVirtualBoundary", new named_type(IfcPhysicalOrVirtualEnum_type), false)); + attributes.push_back(new entity::attribute("InternalOrExternalBoundary", new named_type(IfcInternalOrExternalEnum_type), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelSpaceBoundary_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelatingBuildingElement", new named_type(IfcElement_type), false)); + attributes.push_back(new entity::attribute("RelatedOpeningElement", new named_type(IfcFeatureElementSubtraction_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelVoidsElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RelaxationValue", new named_type(IfcNormalisedRatioMeasure_type), false)); + attributes.push_back(new entity::attribute("InitialStress", new named_type(IfcNormalisedRatioMeasure_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcRelaxation_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("ContextOfItems", new named_type(IfcRepresentationContext_type), false)); + attributes.push_back(new entity::attribute("RepresentationIdentifier", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("RepresentationType", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Items", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcRepresentationItem_type)), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRepresentation_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ContextIdentifier", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("ContextType", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcRepresentationContext_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcRepresentationItem_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("MappingOrigin", new named_type(IfcAxis2Placement_type), false)); + attributes.push_back(new entity::attribute("MappedRepresentation", new named_type(IfcRepresentation_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcRepresentationMap_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcResource_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Axis", new named_type(IfcAxis1Placement_type), false)); + attributes.push_back(new entity::attribute("Angle", new named_type(IfcPlaneAngleMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRevolvedAreaSolid_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("Thickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("RibHeight", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("RibWidth", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("RibSpacing", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("Direction", new named_type(IfcRibPlateDirectionEnum_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRibPlateProfileProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Height", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("BottomRadius", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRightCircularCone_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Height", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("Radius", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRightCircularCylinder_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ShapeType", new named_type(IfcRoofTypeEnum_type), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRoof_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("GlobalId", new named_type(IfcGloballyUniqueId_type), false)); + attributes.push_back(new entity::attribute("OwnerHistory", new named_type(IfcOwnerHistory_type), false)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRoot_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Radius", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRoundedEdgeFeature_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("RoundingRadius", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcRoundedRectangleProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Prefix", new named_type(IfcSIPrefix_type), true)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcSIUnitName_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(true); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSIUnit_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcSanitaryTerminalTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSanitaryTerminalType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(18); + attributes.push_back(new entity::attribute("ActualStart", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("EarlyStart", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("LateStart", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("ScheduleStart", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("ActualFinish", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("EarlyFinish", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("LateFinish", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("ScheduleFinish", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("ScheduleDuration", new named_type(IfcTimeMeasure_type), true)); + attributes.push_back(new entity::attribute("ActualDuration", new named_type(IfcTimeMeasure_type), true)); + attributes.push_back(new entity::attribute("RemainingTime", new named_type(IfcTimeMeasure_type), true)); + attributes.push_back(new entity::attribute("FreeFloat", new named_type(IfcTimeMeasure_type), true)); + attributes.push_back(new entity::attribute("TotalFloat", new named_type(IfcTimeMeasure_type), true)); + attributes.push_back(new entity::attribute("IsCritical", new simple_type(simple_type::boolean_type), true)); + attributes.push_back(new entity::attribute("StatusTime", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("StartFloat", new named_type(IfcTimeMeasure_type), true)); + attributes.push_back(new entity::attribute("FinishFloat", new named_type(IfcTimeMeasure_type), true)); + attributes.push_back(new entity::attribute("Completion", new named_type(IfcPositiveRatioMeasure_type), true)); + std::vector derived; derived.reserve(23); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcScheduleTimeControl_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("SectionType", new named_type(IfcSectionTypeEnum_type), false)); + attributes.push_back(new entity::attribute("StartProfile", new named_type(IfcProfileDef_type), false)); + attributes.push_back(new entity::attribute("EndProfile", new named_type(IfcProfileDef_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSectionProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("LongitudinalStartPosition", new named_type(IfcLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("LongitudinalEndPosition", new named_type(IfcLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("TransversePosition", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("ReinforcementRole", new named_type(IfcReinforcingBarRoleEnum_type), false)); + attributes.push_back(new entity::attribute("SectionDefinition", new named_type(IfcSectionProperties_type), false)); + attributes.push_back(new entity::attribute("CrossSectionReinforcementDefinitions", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcReinforcementBarProperties_type)), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSectionReinforcementProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("SpineCurve", new named_type(IfcCompositeCurve_type), false)); + attributes.push_back(new entity::attribute("CrossSections", new aggregation_type(aggregation_type::list_type, 2, -1, new named_type(IfcProfileDef_type)), false)); + attributes.push_back(new entity::attribute("CrossSectionPositions", new aggregation_type(aggregation_type::list_type, 2, -1, new named_type(IfcAxis2Placement3D_type)), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSectionedSpine_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcSensorTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSensorType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ServiceLifeType", new named_type(IfcServiceLifeTypeEnum_type), false)); + attributes.push_back(new entity::attribute("ServiceLifeDuration", new named_type(IfcTimeMeasure_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcServiceLife_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcServiceLifeFactorTypeEnum_type), false)); + attributes.push_back(new entity::attribute("UpperValue", new named_type(IfcMeasureValue_type), true)); + attributes.push_back(new entity::attribute("MostUsedValue", new named_type(IfcMeasureValue_type), false)); + attributes.push_back(new entity::attribute("LowerValue", new named_type(IfcMeasureValue_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcServiceLifeFactor_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("ShapeRepresentations", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcShapeModel_type)), false)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("ProductDefinitional", new simple_type(simple_type::logical_type), false)); + attributes.push_back(new entity::attribute("PartOfProductDefinitionShape", new named_type(IfcProductDefinitionShape_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcShapeAspect_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcShapeModel_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcShapeRepresentation_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("SbsmBoundary", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcShell_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcShellBasedSurfaceModel_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcSimpleProperty_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("RefLatitude", new named_type(IfcCompoundPlaneAngleMeasure_type), true)); + attributes.push_back(new entity::attribute("RefLongitude", new named_type(IfcCompoundPlaneAngleMeasure_type), true)); + attributes.push_back(new entity::attribute("RefElevation", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("LandTitleNumber", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("SiteAddress", new named_type(IfcPostalAddress_type), true)); + std::vector derived; derived.reserve(14); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSite_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcSlabTypeEnum_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSlab_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcSlabTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSlabType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("SlippageX", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("SlippageY", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("SlippageZ", new named_type(IfcLengthMeasure_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSlippageConnectionCondition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcSolidModel_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("IsAttenuating", new named_type(IfcBoolean_type), false)); + attributes.push_back(new entity::attribute("SoundScale", new named_type(IfcSoundScaleEnum_type), true)); + attributes.push_back(new entity::attribute("SoundValues", new aggregation_type(aggregation_type::list_type, 1, 8, new named_type(IfcSoundValue_type)), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSoundProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("SoundLevelTimeSeries", new named_type(IfcTimeSeries_type), true)); + attributes.push_back(new entity::attribute("Frequency", new named_type(IfcFrequencyMeasure_type), false)); + attributes.push_back(new entity::attribute("SoundLevelSingleValue", new named_type(IfcDerivedMeasureValue_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSoundValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("InteriorOrExteriorSpace", new named_type(IfcInternalOrExternalEnum_type), false)); + attributes.push_back(new entity::attribute("ElevationWithFlooring", new named_type(IfcLengthMeasure_type), true)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSpace_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcSpaceHeaterTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSpaceHeaterType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("SpaceProgramIdentifier", new named_type(IfcIdentifier_type), false)); + attributes.push_back(new entity::attribute("MaxRequiredArea", new named_type(IfcAreaMeasure_type), true)); + attributes.push_back(new entity::attribute("MinRequiredArea", new named_type(IfcAreaMeasure_type), true)); + attributes.push_back(new entity::attribute("RequestedLocation", new named_type(IfcSpatialStructureElement_type), true)); + attributes.push_back(new entity::attribute("StandardRequiredArea", new named_type(IfcAreaMeasure_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSpaceProgram_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(10); + attributes.push_back(new entity::attribute("ApplicableValueRatio", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("ThermalLoadSource", new named_type(IfcThermalLoadSourceEnum_type), false)); + attributes.push_back(new entity::attribute("PropertySource", new named_type(IfcPropertySourceEnum_type), false)); + attributes.push_back(new entity::attribute("SourceDescription", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("MaximumValue", new named_type(IfcPowerMeasure_type), false)); + attributes.push_back(new entity::attribute("MinimumValue", new named_type(IfcPowerMeasure_type), true)); + attributes.push_back(new entity::attribute("ThermalLoadTimeSeriesValues", new named_type(IfcTimeSeries_type), true)); + attributes.push_back(new entity::attribute("UserDefinedThermalLoadSource", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("UserDefinedPropertySource", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("ThermalLoadType", new named_type(IfcThermalLoadTypeEnum_type), false)); + std::vector derived; derived.reserve(14); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSpaceThermalLoadProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcSpaceTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSpaceType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("LongName", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("CompositionType", new named_type(IfcElementCompositionEnum_type), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSpatialStructureElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSpatialStructureElementType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Radius", new named_type(IfcPositiveLengthMeasure_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcSphere_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcStackTerminalTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStackTerminalType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ShapeType", new named_type(IfcStairTypeEnum_type), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStair_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("NumberOfRiser", new simple_type(simple_type::integer_type), true)); + attributes.push_back(new entity::attribute("NumberOfTreads", new simple_type(simple_type::integer_type), true)); + attributes.push_back(new entity::attribute("RiserHeight", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("TreadLength", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(12); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStairFlight_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcStairFlightTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStairFlightType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("DestabilizingLoad", new simple_type(simple_type::boolean_type), false)); + attributes.push_back(new entity::attribute("CausedBy", new named_type(IfcStructuralReaction_type), true)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralAction_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("AppliedLoad", new named_type(IfcStructuralLoad_type), false)); + attributes.push_back(new entity::attribute("GlobalOrLocal", new named_type(IfcGlobalOrLocalEnum_type), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralActivity_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcAnalysisModelTypeEnum_type), false)); + attributes.push_back(new entity::attribute("OrientationOf2DPlane", new named_type(IfcAxis2Placement3D_type), true)); + attributes.push_back(new entity::attribute("LoadedBy", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcStructuralLoadGroup_type)), true)); + attributes.push_back(new entity::attribute("HasResults", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcStructuralResultGroup_type)), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralAnalysisModel_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("AppliedCondition", new named_type(IfcBoundaryCondition_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralConnection_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcStructuralConnectionCondition_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralCurveConnection_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcStructuralCurveTypeEnum_type), false)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralCurveMember_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralCurveMemberVarying_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralItem_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ProjectedOrTrue", new named_type(IfcProjectedOrTrueLengthEnum_type), false)); + std::vector derived; derived.reserve(12); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralLinearAction_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("VaryingAppliedLoadLocation", new named_type(IfcShapeAspect_type), false)); + attributes.push_back(new entity::attribute("SubsequentAppliedLoads", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcStructuralLoad_type)), false)); + std::vector derived; derived.reserve(14); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralLinearActionVarying_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcStructuralLoad_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcLoadGroupTypeEnum_type), false)); + attributes.push_back(new entity::attribute("ActionType", new named_type(IfcActionTypeEnum_type), false)); + attributes.push_back(new entity::attribute("ActionSource", new named_type(IfcActionSourceTypeEnum_type), false)); + attributes.push_back(new entity::attribute("Coefficient", new named_type(IfcRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("Purpose", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralLoadGroup_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("LinearForceX", new named_type(IfcLinearForceMeasure_type), true)); + attributes.push_back(new entity::attribute("LinearForceY", new named_type(IfcLinearForceMeasure_type), true)); + attributes.push_back(new entity::attribute("LinearForceZ", new named_type(IfcLinearForceMeasure_type), true)); + attributes.push_back(new entity::attribute("LinearMomentX", new named_type(IfcLinearMomentMeasure_type), true)); + attributes.push_back(new entity::attribute("LinearMomentY", new named_type(IfcLinearMomentMeasure_type), true)); + attributes.push_back(new entity::attribute("LinearMomentZ", new named_type(IfcLinearMomentMeasure_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralLoadLinearForce_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("PlanarForceX", new named_type(IfcPlanarForceMeasure_type), true)); + attributes.push_back(new entity::attribute("PlanarForceY", new named_type(IfcPlanarForceMeasure_type), true)); + attributes.push_back(new entity::attribute("PlanarForceZ", new named_type(IfcPlanarForceMeasure_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralLoadPlanarForce_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("DisplacementX", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("DisplacementY", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("DisplacementZ", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("RotationalDisplacementRX", new named_type(IfcPlaneAngleMeasure_type), true)); + attributes.push_back(new entity::attribute("RotationalDisplacementRY", new named_type(IfcPlaneAngleMeasure_type), true)); + attributes.push_back(new entity::attribute("RotationalDisplacementRZ", new named_type(IfcPlaneAngleMeasure_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralLoadSingleDisplacement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Distortion", new named_type(IfcCurvatureMeasure_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralLoadSingleDisplacementDistortion_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("ForceX", new named_type(IfcForceMeasure_type), true)); + attributes.push_back(new entity::attribute("ForceY", new named_type(IfcForceMeasure_type), true)); + attributes.push_back(new entity::attribute("ForceZ", new named_type(IfcForceMeasure_type), true)); + attributes.push_back(new entity::attribute("MomentX", new named_type(IfcTorqueMeasure_type), true)); + attributes.push_back(new entity::attribute("MomentY", new named_type(IfcTorqueMeasure_type), true)); + attributes.push_back(new entity::attribute("MomentZ", new named_type(IfcTorqueMeasure_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralLoadSingleForce_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("WarpingMoment", new named_type(IfcWarpingMomentMeasure_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralLoadSingleForceWarping_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcStructuralLoadStatic_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("DeltaT_Constant", new named_type(IfcThermodynamicTemperatureMeasure_type), true)); + attributes.push_back(new entity::attribute("DeltaT_Y", new named_type(IfcThermodynamicTemperatureMeasure_type), true)); + attributes.push_back(new entity::attribute("DeltaT_Z", new named_type(IfcThermodynamicTemperatureMeasure_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralLoadTemperature_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralMember_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ProjectedOrTrue", new named_type(IfcProjectedOrTrueLengthEnum_type), false)); + std::vector derived; derived.reserve(12); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralPlanarAction_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("VaryingAppliedLoadLocation", new named_type(IfcShapeAspect_type), false)); + attributes.push_back(new entity::attribute("SubsequentAppliedLoads", new aggregation_type(aggregation_type::list_type, 2, -1, new named_type(IfcStructuralLoad_type)), false)); + std::vector derived; derived.reserve(14); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralPlanarActionVarying_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralPointAction_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralPointConnection_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralPointReaction_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(16); + attributes.push_back(new entity::attribute("TorsionalConstantX", new named_type(IfcMomentOfInertiaMeasure_type), true)); + attributes.push_back(new entity::attribute("MomentOfInertiaYZ", new named_type(IfcMomentOfInertiaMeasure_type), true)); + attributes.push_back(new entity::attribute("MomentOfInertiaY", new named_type(IfcMomentOfInertiaMeasure_type), true)); + attributes.push_back(new entity::attribute("MomentOfInertiaZ", new named_type(IfcMomentOfInertiaMeasure_type), true)); + attributes.push_back(new entity::attribute("WarpingConstant", new named_type(IfcWarpingConstantMeasure_type), true)); + attributes.push_back(new entity::attribute("ShearCentreZ", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("ShearCentreY", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("ShearDeformationAreaZ", new named_type(IfcAreaMeasure_type), true)); + attributes.push_back(new entity::attribute("ShearDeformationAreaY", new named_type(IfcAreaMeasure_type), true)); + attributes.push_back(new entity::attribute("MaximumSectionModulusY", new named_type(IfcSectionModulusMeasure_type), true)); + attributes.push_back(new entity::attribute("MinimumSectionModulusY", new named_type(IfcSectionModulusMeasure_type), true)); + attributes.push_back(new entity::attribute("MaximumSectionModulusZ", new named_type(IfcSectionModulusMeasure_type), true)); + attributes.push_back(new entity::attribute("MinimumSectionModulusZ", new named_type(IfcSectionModulusMeasure_type), true)); + attributes.push_back(new entity::attribute("TorsionalSectionModulus", new named_type(IfcSectionModulusMeasure_type), true)); + attributes.push_back(new entity::attribute("CentreOfGravityInX", new named_type(IfcLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("CentreOfGravityInY", new named_type(IfcLengthMeasure_type), true)); + std::vector derived; derived.reserve(23); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralProfileProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralReaction_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("TheoryType", new named_type(IfcAnalysisTheoryTypeEnum_type), false)); + attributes.push_back(new entity::attribute("ResultForLoadGroup", new named_type(IfcStructuralLoadGroup_type), true)); + attributes.push_back(new entity::attribute("IsLinear", new simple_type(simple_type::boolean_type), false)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralResultGroup_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("ShearAreaZ", new named_type(IfcAreaMeasure_type), true)); + attributes.push_back(new entity::attribute("ShearAreaY", new named_type(IfcAreaMeasure_type), true)); + attributes.push_back(new entity::attribute("PlasticShapeFactorY", new named_type(IfcPositiveRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("PlasticShapeFactorZ", new named_type(IfcPositiveRatioMeasure_type), true)); + std::vector derived; derived.reserve(27); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralSteelProfileProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralSurfaceConnection_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcStructuralSurfaceTypeEnum_type), false)); + attributes.push_back(new entity::attribute("Thickness", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralSurfaceMember_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("SubsequentThickness", new aggregation_type(aggregation_type::list_type, 2, -1, new named_type(IfcPositiveLengthMeasure_type)), false)); + attributes.push_back(new entity::attribute("VaryingThicknessLocation", new named_type(IfcShapeAspect_type), false)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStructuralSurfaceMemberVarying_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcStructuredDimensionCallout_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStyleModel_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Item", new named_type(IfcRepresentationItem_type), true)); + attributes.push_back(new entity::attribute("Styles", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcPresentationStyleAssignment_type)), false)); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStyledItem_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcStyledRepresentation_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("SubContractor", new named_type(IfcActorSelect_type), true)); + attributes.push_back(new entity::attribute("JobDescription", new named_type(IfcText_type), true)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSubContractResource_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ParentEdge", new named_type(IfcEdge_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSubedge_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcSurface_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("Directrix", new named_type(IfcCurve_type), false)); + attributes.push_back(new entity::attribute("StartParam", new named_type(IfcParameterValue_type), false)); + attributes.push_back(new entity::attribute("EndParam", new named_type(IfcParameterValue_type), false)); + attributes.push_back(new entity::attribute("ReferenceSurface", new named_type(IfcSurface_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSurfaceCurveSweptAreaSolid_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ExtrudedDirection", new named_type(IfcDirection_type), false)); + attributes.push_back(new entity::attribute("Depth", new named_type(IfcLengthMeasure_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSurfaceOfLinearExtrusion_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("AxisPosition", new named_type(IfcAxis1Placement_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSurfaceOfRevolution_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Side", new named_type(IfcSurfaceSide_type), false)); + attributes.push_back(new entity::attribute("Styles", new aggregation_type(aggregation_type::set_type, 1, 5, new named_type(IfcSurfaceStyleElementSelect_type)), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSurfaceStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("DiffuseTransmissionColour", new named_type(IfcColourRgb_type), false)); + attributes.push_back(new entity::attribute("DiffuseReflectionColour", new named_type(IfcColourRgb_type), false)); + attributes.push_back(new entity::attribute("TransmissionColour", new named_type(IfcColourRgb_type), false)); + attributes.push_back(new entity::attribute("ReflectanceColour", new named_type(IfcColourRgb_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSurfaceStyleLighting_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RefractionIndex", new named_type(IfcReal_type), true)); + attributes.push_back(new entity::attribute("DispersionFactor", new named_type(IfcReal_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcSurfaceStyleRefraction_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(8); + attributes.push_back(new entity::attribute("Transparency", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("DiffuseColour", new named_type(IfcColourOrFactor_type), true)); + attributes.push_back(new entity::attribute("TransmissionColour", new named_type(IfcColourOrFactor_type), true)); + attributes.push_back(new entity::attribute("DiffuseTransmissionColour", new named_type(IfcColourOrFactor_type), true)); + attributes.push_back(new entity::attribute("ReflectionColour", new named_type(IfcColourOrFactor_type), true)); + attributes.push_back(new entity::attribute("SpecularColour", new named_type(IfcColourOrFactor_type), true)); + attributes.push_back(new entity::attribute("SpecularHighlight", new named_type(IfcSpecularHighlightSelect_type), true)); + attributes.push_back(new entity::attribute("ReflectanceMethod", new named_type(IfcReflectanceMethodEnum_type), false)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSurfaceStyleRendering_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("SurfaceColour", new named_type(IfcColourRgb_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcSurfaceStyleShading_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Textures", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcSurfaceTexture_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcSurfaceStyleWithTextures_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("RepeatS", new simple_type(simple_type::boolean_type), false)); + attributes.push_back(new entity::attribute("RepeatT", new simple_type(simple_type::boolean_type), false)); + attributes.push_back(new entity::attribute("TextureType", new named_type(IfcSurfaceTextureEnum_type), false)); + attributes.push_back(new entity::attribute("TextureTransform", new named_type(IfcCartesianTransformationOperator2D_type), true)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSurfaceTexture_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("SweptArea", new named_type(IfcProfileDef_type), false)); + attributes.push_back(new entity::attribute("Position", new named_type(IfcAxis2Placement3D_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcSweptAreaSolid_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("Directrix", new named_type(IfcCurve_type), false)); + attributes.push_back(new entity::attribute("Radius", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("InnerRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("StartParam", new named_type(IfcParameterValue_type), false)); + attributes.push_back(new entity::attribute("EndParam", new named_type(IfcParameterValue_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSweptDiskSolid_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("SweptCurve", new named_type(IfcProfileDef_type), false)); + attributes.push_back(new entity::attribute("Position", new named_type(IfcAxis2Placement3D_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcSweptSurface_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcSwitchingDeviceTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSwitchingDeviceType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("StyleOfSymbol", new named_type(IfcSymbolStyleSelect_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcSymbolStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSystem_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcSystemFurnitureElementType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(10); + attributes.push_back(new entity::attribute("Depth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FlangeWidth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("WebThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FlangeThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FilletRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("FlangeEdgeRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("WebEdgeRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("WebSlope", new named_type(IfcPlaneAngleMeasure_type), true)); + attributes.push_back(new entity::attribute("FlangeSlope", new named_type(IfcPlaneAngleMeasure_type), true)); + attributes.push_back(new entity::attribute("CentreOfGravityInY", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(13); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTShapeProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Name", new simple_type(simple_type::string_type), false)); + attributes.push_back(new entity::attribute("Rows", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcTableRow_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcTable_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RowCells", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcValue_type)), false)); + attributes.push_back(new entity::attribute("IsHeading", new simple_type(simple_type::boolean_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcTableRow_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcTankTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTankType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("TaskId", new named_type(IfcIdentifier_type), false)); + attributes.push_back(new entity::attribute("Status", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("WorkMethod", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("IsMilestone", new simple_type(simple_type::boolean_type), false)); + attributes.push_back(new entity::attribute("Priority", new simple_type(simple_type::integer_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTask_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("TelephoneNumbers", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcLabel_type)), true)); + attributes.push_back(new entity::attribute("FacsimileNumbers", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcLabel_type)), true)); + attributes.push_back(new entity::attribute("PagerNumber", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("ElectronicMailAddresses", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcLabel_type)), true)); + attributes.push_back(new entity::attribute("WWWHomePageURL", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTelecomAddress_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(8); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcTendonTypeEnum_type), false)); + attributes.push_back(new entity::attribute("NominalDiameter", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("CrossSectionArea", new named_type(IfcAreaMeasure_type), false)); + attributes.push_back(new entity::attribute("TensionForce", new named_type(IfcForceMeasure_type), true)); + attributes.push_back(new entity::attribute("PreStress", new named_type(IfcPressureMeasure_type), true)); + attributes.push_back(new entity::attribute("FrictionCoefficient", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("AnchorageSlip", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("MinCurvatureRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(17); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTendon_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTendonAnchor_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("AnnotatedCurve", new named_type(IfcAnnotationCurveOccurrence_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTerminatorSymbol_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("Literal", new named_type(IfcPresentableText_type), false)); + attributes.push_back(new entity::attribute("Placement", new named_type(IfcAxis2Placement_type), false)); + attributes.push_back(new entity::attribute("Path", new named_type(IfcTextPath_type), false)); + std::vector derived; derived.reserve(3); + derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTextLiteral_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Extent", new named_type(IfcPlanarExtent_type), false)); + attributes.push_back(new entity::attribute("BoxAlignment", new named_type(IfcBoxAlignment_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTextLiteralWithExtent_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("TextCharacterAppearance", new named_type(IfcCharacterStyleSelect_type), true)); + attributes.push_back(new entity::attribute("TextStyle", new named_type(IfcTextStyleSelect_type), true)); + attributes.push_back(new entity::attribute("TextFontStyle", new named_type(IfcTextFontSelect_type), false)); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTextStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("FontFamily", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcTextFontName_type)), true)); + attributes.push_back(new entity::attribute("FontStyle", new named_type(IfcFontStyle_type), true)); + attributes.push_back(new entity::attribute("FontVariant", new named_type(IfcFontVariant_type), true)); + attributes.push_back(new entity::attribute("FontWeight", new named_type(IfcFontWeight_type), true)); + attributes.push_back(new entity::attribute("FontSize", new named_type(IfcSizeSelect_type), false)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTextStyleFontModel_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Colour", new named_type(IfcColour_type), false)); + attributes.push_back(new entity::attribute("BackgroundColour", new named_type(IfcColour_type), true)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcTextStyleForDefinedFont_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(7); + attributes.push_back(new entity::attribute("TextIndent", new named_type(IfcSizeSelect_type), true)); + attributes.push_back(new entity::attribute("TextAlign", new named_type(IfcTextAlignment_type), true)); + attributes.push_back(new entity::attribute("TextDecoration", new named_type(IfcTextDecoration_type), true)); + attributes.push_back(new entity::attribute("LetterSpacing", new named_type(IfcSizeSelect_type), true)); + attributes.push_back(new entity::attribute("WordSpacing", new named_type(IfcSizeSelect_type), true)); + attributes.push_back(new entity::attribute("TextTransform", new named_type(IfcTextTransformation_type), true)); + attributes.push_back(new entity::attribute("LineHeight", new named_type(IfcSizeSelect_type), true)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTextStyleTextModel_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("BoxHeight", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("BoxWidth", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("BoxSlantAngle", new named_type(IfcPlaneAngleMeasure_type), true)); + attributes.push_back(new entity::attribute("BoxRotateAngle", new named_type(IfcPlaneAngleMeasure_type), true)); + attributes.push_back(new entity::attribute("CharacterSpacing", new named_type(IfcSizeSelect_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTextStyleWithBoxCharacteristics_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcTextureCoordinate_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Mode", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Parameter", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcSimpleValue_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcTextureCoordinateGenerator_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("TextureMaps", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcVertexBasedTextureMap_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcTextureMap_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Coordinates", new aggregation_type(aggregation_type::list_type, 2, 2, new named_type(IfcParameterValue_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcTextureVertex_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("SpecificHeatCapacity", new named_type(IfcSpecificHeatCapacityMeasure_type), true)); + attributes.push_back(new entity::attribute("BoilingPoint", new named_type(IfcThermodynamicTemperatureMeasure_type), true)); + attributes.push_back(new entity::attribute("FreezingPoint", new named_type(IfcThermodynamicTemperatureMeasure_type), true)); + attributes.push_back(new entity::attribute("ThermalConductivity", new named_type(IfcThermalConductivityMeasure_type), true)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcThermalMaterialProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(8); + attributes.push_back(new entity::attribute("Name", new named_type(IfcLabel_type), false)); + attributes.push_back(new entity::attribute("Description", new named_type(IfcText_type), true)); + attributes.push_back(new entity::attribute("StartTime", new named_type(IfcDateTimeSelect_type), false)); + attributes.push_back(new entity::attribute("EndTime", new named_type(IfcDateTimeSelect_type), false)); + attributes.push_back(new entity::attribute("TimeSeriesDataType", new named_type(IfcTimeSeriesDataTypeEnum_type), false)); + attributes.push_back(new entity::attribute("DataOrigin", new named_type(IfcDataOriginEnum_type), false)); + attributes.push_back(new entity::attribute("UserDefinedDataOrigin", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Unit", new named_type(IfcUnit_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTimeSeries_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ReferencedTimeSeries", new named_type(IfcTimeSeries_type), false)); + attributes.push_back(new entity::attribute("TimeSeriesReferences", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcDocumentSelect_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcTimeSeriesReferenceRelationship_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("ApplicableDates", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcDateTimeSelect_type)), true)); + attributes.push_back(new entity::attribute("TimeSeriesScheduleType", new named_type(IfcTimeSeriesScheduleTypeEnum_type), false)); + attributes.push_back(new entity::attribute("TimeSeries", new named_type(IfcTimeSeries_type), false)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTimeSeriesSchedule_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("ListValues", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcValue_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcTimeSeriesValue_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcTopologicalRepresentationItem_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(4); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTopologyRepresentation_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcTransformerTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTransformerType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::attribute("OperationType", new named_type(IfcTransportElementTypeEnum_type), true)); + attributes.push_back(new entity::attribute("CapacityByWeight", new named_type(IfcMassMeasure_type), true)); + attributes.push_back(new entity::attribute("CapacityByNumber", new named_type(IfcCountMeasure_type), true)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTransportElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcTransportElementTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTransportElementType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("BottomXDim", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("TopXDim", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("YDim", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("TopXOffset", new named_type(IfcLengthMeasure_type), false)); + std::vector derived; derived.reserve(7); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTrapeziumProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("BasisCurve", new named_type(IfcCurve_type), false)); + attributes.push_back(new entity::attribute("Trim1", new aggregation_type(aggregation_type::set_type, 1, 2, new named_type(IfcTrimmingSelect_type)), false)); + attributes.push_back(new entity::attribute("Trim2", new aggregation_type(aggregation_type::set_type, 1, 2, new named_type(IfcTrimmingSelect_type)), false)); + attributes.push_back(new entity::attribute("SenseAgreement", new simple_type(simple_type::boolean_type), false)); + attributes.push_back(new entity::attribute("MasterRepresentation", new named_type(IfcTrimmingPreference_type), false)); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTrimmedCurve_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcTubeBundleTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTubeBundleType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("SecondRepeatFactor", new named_type(IfcVector_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcTwoDirectionRepeatFactor_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("ApplicableOccurrence", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("HasPropertySets", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcPropertySetDefinition_type)), true)); + std::vector derived; derived.reserve(6); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTypeObject_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("RepresentationMaps", new aggregation_type(aggregation_type::list_type, 1, -1, new named_type(IfcRepresentationMap_type)), true)); + attributes.push_back(new entity::attribute("Tag", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcTypeProduct_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(8); + attributes.push_back(new entity::attribute("Depth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FlangeWidth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("WebThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FlangeThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FilletRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("EdgeRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("FlangeSlope", new named_type(IfcPlaneAngleMeasure_type), true)); + attributes.push_back(new entity::attribute("CentreOfGravityInX", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(11); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcUShapeProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("Units", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcUnit_type)), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcUnitAssignment_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcUnitaryEquipmentTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcUnitaryEquipmentType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcValveTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcValveType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("Orientation", new named_type(IfcDirection_type), false)); + attributes.push_back(new entity::attribute("Magnitude", new named_type(IfcLengthMeasure_type), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcVector_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(0); + + IfcVertex_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("TextureVertices", new aggregation_type(aggregation_type::list_type, 3, -1, new named_type(IfcTextureVertex_type)), false)); + attributes.push_back(new entity::attribute("TexturePoints", new aggregation_type(aggregation_type::list_type, 3, -1, new named_type(IfcCartesianPoint_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcVertexBasedTextureMap_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("LoopVertex", new named_type(IfcVertex_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcVertexLoop_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("VertexGeometry", new named_type(IfcPoint_type), false)); + std::vector derived; derived.reserve(1); + derived.push_back(false); + IfcVertexPoint_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcVibrationIsolatorTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcVibrationIsolatorType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcVirtualElement_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("IntersectingAxes", new aggregation_type(aggregation_type::list_type, 2, 2, new named_type(IfcGridAxis_type)), false)); + attributes.push_back(new entity::attribute("OffsetDistances", new aggregation_type(aggregation_type::list_type, 2, 3, new named_type(IfcLengthMeasure_type)), false)); + std::vector derived; derived.reserve(2); + derived.push_back(false); derived.push_back(false); + IfcVirtualGridIntersection_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWall_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWallStandardCase_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcWallTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWallType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::attribute("PredefinedType", new named_type(IfcWasteTerminalTypeEnum_type), false)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWasteTerminalType_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(7); + attributes.push_back(new entity::attribute("IsPotable", new simple_type(simple_type::boolean_type), true)); + attributes.push_back(new entity::attribute("Hardness", new named_type(IfcIonConcentrationMeasure_type), true)); + attributes.push_back(new entity::attribute("AlkalinityConcentration", new named_type(IfcIonConcentrationMeasure_type), true)); + attributes.push_back(new entity::attribute("AcidityConcentration", new named_type(IfcIonConcentrationMeasure_type), true)); + attributes.push_back(new entity::attribute("ImpuritiesContent", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("PHLevel", new named_type(IfcPHMeasure_type), true)); + attributes.push_back(new entity::attribute("DissolvedSolidsContent", new named_type(IfcNormalisedRatioMeasure_type), true)); + std::vector derived; derived.reserve(8); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWaterProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::attribute("OverallHeight", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("OverallWidth", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(10); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWindow_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(9); + attributes.push_back(new entity::attribute("LiningDepth", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("LiningThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("TransomThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("MullionThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("FirstTransomOffset", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("SecondTransomOffset", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("FirstMullionOffset", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("SecondMullionOffset", new named_type(IfcNormalisedRatioMeasure_type), true)); + attributes.push_back(new entity::attribute("ShapeAspectStyle", new named_type(IfcShapeAspect_type), true)); + std::vector derived; derived.reserve(13); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWindowLiningProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(5); + attributes.push_back(new entity::attribute("OperationType", new named_type(IfcWindowPanelOperationEnum_type), false)); + attributes.push_back(new entity::attribute("PanelPosition", new named_type(IfcWindowPanelPositionEnum_type), false)); + attributes.push_back(new entity::attribute("FrameDepth", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("FrameThickness", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("ShapeAspectStyle", new named_type(IfcShapeAspect_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWindowPanelProperties_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::attribute("ConstructionType", new named_type(IfcWindowStyleConstructionEnum_type), false)); + attributes.push_back(new entity::attribute("OperationType", new named_type(IfcWindowStyleOperationEnum_type), false)); + attributes.push_back(new entity::attribute("ParameterTakesPrecedence", new simple_type(simple_type::boolean_type), false)); + attributes.push_back(new entity::attribute("Sizeable", new simple_type(simple_type::boolean_type), false)); + std::vector derived; derived.reserve(12); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWindowStyle_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(10); + attributes.push_back(new entity::attribute("Identifier", new named_type(IfcIdentifier_type), false)); + attributes.push_back(new entity::attribute("CreationDate", new named_type(IfcDateTimeSelect_type), false)); + attributes.push_back(new entity::attribute("Creators", new aggregation_type(aggregation_type::set_type, 1, -1, new named_type(IfcPerson_type)), true)); + attributes.push_back(new entity::attribute("Purpose", new named_type(IfcLabel_type), true)); + attributes.push_back(new entity::attribute("Duration", new named_type(IfcTimeMeasure_type), true)); + attributes.push_back(new entity::attribute("TotalFloat", new named_type(IfcTimeMeasure_type), true)); + attributes.push_back(new entity::attribute("StartTime", new named_type(IfcDateTimeSelect_type), false)); + attributes.push_back(new entity::attribute("FinishTime", new named_type(IfcDateTimeSelect_type), true)); + attributes.push_back(new entity::attribute("WorkControlType", new named_type(IfcWorkControlTypeEnum_type), true)); + attributes.push_back(new entity::attribute("UserDefinedControlType", new named_type(IfcLabel_type), true)); + std::vector derived; derived.reserve(15); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWorkControl_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(15); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWorkPlan_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(15); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcWorkSchedule_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::attribute("Depth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FlangeWidth", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("WebThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FlangeThickness", new named_type(IfcPositiveLengthMeasure_type), false)); + attributes.push_back(new entity::attribute("FilletRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + attributes.push_back(new entity::attribute("EdgeRadius", new named_type(IfcPositiveLengthMeasure_type), true)); + std::vector derived; derived.reserve(9); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcZShapeProfileDef_type->set_attributes(attributes, derived); + } + { + std::vector attributes; attributes.reserve(0); + std::vector derived; derived.reserve(5); + derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); + IfcZone_type->set_attributes(attributes, derived); + } +} + +#endif diff --git a/src/ifcparse/IfcSchema.h b/src/ifcparse/IfcSchema.h new file mode 100644 index 0000000000..75adf4c541 --- /dev/null +++ b/src/ifcparse/IfcSchema.h @@ -0,0 +1,245 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +#ifndef IFCSCHEMA_H +#define IFCSCHEMA_H + +#include +#include +#include + +class declaration; +class type_declaration; +class select_type; +class enumeration_type; +class entity; + +class parameter_type { +}; + +class named_type : public parameter_type { +protected: + declaration* declared_type_; +public: + named_type(declaration* declared_type) + : declared_type_(declared_type) {} + + declaration* declared_type() const { return declared_type_; } +}; + +class simple_type : public parameter_type { +public: + typedef enum { binary_type, boolean_type, integer_type, logical_type, number_type, real_type, string_type } data_type; +protected: + data_type declared_type_; +public: + simple_type(data_type declared_type) + : declared_type_(declared_type) {} + + data_type declared_type() const { return declared_type_; } +}; + +class aggregation_type : public parameter_type { +public: + typedef enum { array_type, bag_type, list_type, set_type } aggregate_type; +protected: + aggregate_type type_of_aggregation_; + int bound1_, bound2_; + parameter_type* type_of_element_; +public: + aggregation_type(aggregate_type type_of_aggregation, int bound1, int bound2, parameter_type* type_of_element) + : type_of_aggregation_(type_of_aggregation) + , bound1_(bound1) + , bound2_(bound2) + , type_of_element_(type_of_element) + {} + + aggregate_type type_of_aggregation() const { type_of_aggregation_; } + int bound1() const { return bound1_; } + int bound2() const { return bound2_; } + parameter_type* type_of_element() const { return type_of_element_; } +}; + +class declaration { +protected: + std::string name_; + +public: + declaration(const std::string& name) + : name_(name) {} + + const std::string& name() const { return name_; } + + virtual const type_declaration* as_type_declaration() const { return static_cast(0); } + virtual const select_type* as_select_type() const { return static_cast(0); } + virtual const enumeration_type* as_enumeration_type() const { return static_cast(0); } + virtual const entity* as_entity() const { return static_cast(0); } +}; + +class type_declaration : public declaration { +protected: + const parameter_type* declared_type_; + +public: + type_declaration(const std::string& name, const parameter_type* declared_type) + : declaration(name) + , declared_type_(declared_type) {} + + const parameter_type* declared_type() const { return declared_type_; } + + virtual const type_declaration* as_type_declaration() const { return this; } +}; + +class select_type : public declaration { +protected: + std::vector select_list_; +public: + select_type(const std::string& name, const std::vector& select_list) + : declaration(name) + , select_list_(select_list) {} + + const std::vector& select_list() const { return select_list_; } + + virtual const select_type* as_select_type() const { return this; } +}; + +class enumeration_type : public declaration { +protected: + std::vector enumeration_items_; +public: + enumeration_type(const std::string& name, const std::vector& enumeration_items) + : declaration(name) + , enumeration_items_(enumeration_items) {} + + const std::vector& enumeration_items() const { return enumeration_items_; } + + virtual const enumeration_type* as_enumeration_type() const { return this; } +}; + +class entity : public declaration { +public: + class attribute { + protected: + std::string name_; + const parameter_type* type_of_attribute_; + bool optional_; + + public: + attribute(const std::string& name, parameter_type* type_of_attribute, bool optional) + : name_(name) + , type_of_attribute_(type_of_attribute) + , optional_(optional) {} + + const std::string& name() const { return name_; } + const parameter_type* type_of_attribute() const { return type_of_attribute_; } + bool optional() const { return optional_; } + }; + +protected: + const entity* supertype_; /* NB: IFC explicitly allows only single inheritance */ + std::vector subtypes_; + + std::vector attributes_; + std::vector derived_; + +public: + entity(const std::string& name, entity* supertype) + : declaration(name) + , supertype_(supertype) + {} + + void set_subtypes(const std::vector& subtypes) { + subtypes_ = subtypes; + } + + void set_attributes(const std::vector& attributes, const std::vector& derived) { + attributes_ = attributes; + derived_ = derived; + } + + const std::vector& subtypes() const { return subtypes_; } + const std::vector& attributes() const { return attributes_; } + const std::vector& derived() const { return derived_; } + + const std::vector all_attributes() const { + std::vector attrs; + attrs.reserve(derived_.size()); + std::vector::iterator it = attrs.begin(); + if (supertype_) { + const std::vector supertype_attrs = supertype_->all_attributes(); + it = std::copy(supertype_attrs.begin(), supertype_attrs.end(), it); + } + std::copy(attributes_.begin(), attributes_.end(), it); + return attrs; + } + + virtual const entity* as_entity() const { return this; } +}; + +class schema_definition { +private: + std::string name_; + + std::vector declarations_; + + std::vector type_declarations_; + std::vector select_types_; + std::vector enumeration_types_; + + class declaration_by_name_cmp : public std::binary_function { + public: + bool operator()(const declaration* decl, const std::string& name) { + return decl->name() < name; + } + }; + +public: + schema_definition(const std::string& name, const std::vector& declarations) + : name_(name) + , declarations_(declarations) + { + for (std::vector::const_iterator it = declarations_.begin(); it != declarations_.end(); ++it) { + if ((**it).as_type_declaration()) type_declarations_.push_back((**it).as_type_declaration()); + if ((**it).as_select_type()) select_types_.push_back((**it).as_select_type()); + if ((**it).as_enumeration_type()) enumeration_types_.push_back((**it).as_enumeration_type()); + } + } + + ~schema_definition() { + for (std::vector::const_iterator it = declarations_.begin(); it != declarations_.end(); ++it) { + delete *it; + } + } + + const declaration* declaration_by_name(const std::string& name) { + std::vector::const_iterator it = std::lower_bound(declarations_.begin(), declarations_.end(), name, declaration_by_name_cmp()); + if (it == declarations_.end() || (**it).name() != name) { + throw; + } else { + return *it; + } + } + + const std::vector& declarations() { return declarations_; } + const std::vector& type_declarations() { return type_declarations_; } + const std::vector& select_types() { return select_types_; } + const std::vector& enumeration_types() { return enumeration_types_; } +}; + +#endif \ No newline at end of file From 23beb5691ca99baa381f0ce2aff4f800735e4475 Mon Sep 17 00:00:00 2001 From: Thomas Krijnen Date: Thu, 17 Sep 2015 10:33:19 +0200 Subject: [PATCH 3/4] Detect abstract entities in schema parser --- src/ifcexpressparser/nodes.py | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/src/ifcexpressparser/nodes.py b/src/ifcexpressparser/nodes.py index d21a29df67..31359d46c5 100644 --- a/src/ifcexpressparser/nodes.py +++ b/src/ifcexpressparser/nodes.py @@ -44,15 +44,17 @@ class TypeDeclaration(Node): class EntityDeclaration(Node): name = property(lambda self: self.tokens[1]) attributes = property(lambda self: self.tokens_of_type(ExplicitAttribute)) + abstract = property(lambda self: self.single_token_of_type(SuperTypeExpression) is not None and \ + self.single_token_of_type(SuperTypeExpression).abstract) def init(self): assert self.tokens[0] == 'entity' - s = self.single_token_of_type(SubtypeExpression) + s = self.single_token_of_type(SubTypeExpression) self.inverse = self.single_token_of_type(AttributeList, 'type', 'inverse') self.derive = self.single_token_of_type(AttributeList, 'type', 'derive') self.supertypes = s.types if s else [] def __repr__(self): builder = "" - builder += "Entity(%s)" % (self.name) + builder += "%sEntity(%s)" % ("Abstract " if self.abstract else "", self.name) if len(self.supertypes): builder += "\n Supertypes: %s"%(",".join(self.supertypes)) if len(self.attributes): @@ -106,12 +108,20 @@ class SelectType(Node): class SubSuperTypeExpression(Node): type = property(lambda self: self.tokens[0]) types = property(lambda self: self.tokens[3::2]) + abstract = False def init(self): - assert self.type == self.class_type + if self.tokens[0] == 'abstract': + self.tokens = self.tokens[1:] + self.abstract = True + assert self.type == self.type_relationship -class SubtypeExpression(SubSuperTypeExpression): - class_type = 'subtype' +class SubTypeExpression(SubSuperTypeExpression): + type_relationship = 'subtype' + + +class SuperTypeExpression(SubSuperTypeExpression): + type_relationship = 'supertype' class AttributeList(Node): From d076fa588b310638a42679a158601d296e37233c Mon Sep 17 00:00:00 2001 From: aothms Date: Tue, 8 Sep 2015 20:40:54 +0200 Subject: [PATCH 4/4] Work on runtime representation of schema --- src/ifcconvert/SvgSerializer.cpp | 4 +- src/ifcconvert/XmlSerializer.cpp | 30 +- src/ifcexpressparser/implementation.py | 15 +- src/ifcexpressparser/schema_class.py | 60 +- src/ifcexpressparser/templates.py | 62 +- src/ifcgeom/IfcGeom.h | 10 +- src/ifcgeom/IfcGeomCurves.cpp | 8 +- src/ifcgeom/IfcGeomFaces.cpp | 42 +- src/ifcgeom/IfcGeomFunctions.cpp | 62 +- src/ifcgeom/IfcGeomHelpers.cpp | 8 +- src/ifcgeom/IfcGeomIterator.h | 14 +- src/ifcgeom/IfcGeomRenderStyles.cpp | 12 +- src/ifcgeom/IfcGeomRepresentation.h | 4 +- src/ifcgeom/IfcGeomShapes.cpp | 68 +- src/ifcgeom/IfcGeomWires.cpp | 44 +- src/ifcgeom/IfcRegister.cpp | 12 +- src/ifcgeom/IfcRegisterConvertCurve.h | 2 +- src/ifcgeom/IfcRegisterConvertFace.h | 2 +- src/ifcgeom/IfcRegisterConvertShape.h | 6 +- src/ifcgeom/IfcRegisterConvertShapes.h | 6 +- src/ifcgeom/IfcRegisterConvertWire.h | 2 +- src/ifcgeom/IfcRegisterShapeType.h | 10 +- src/ifcparse/Ifc2x3-schema.cpp | 4142 +++++-- src/ifcparse/Ifc2x3.cpp | 14645 ++++++++++++----------- src/ifcparse/Ifc2x3.h | 5938 ++------- src/ifcparse/IfcFile.h | 4 + src/ifcparse/IfcHierarchyHelper.cpp | 2 +- src/ifcparse/IfcLateBoundEntity.cpp | 27 +- src/ifcparse/IfcLateBoundEntity.h | 16 +- src/ifcparse/IfcParse.cpp | 215 +- src/ifcparse/IfcParse.h | 3 +- src/ifcparse/IfcSchema.cpp | 21 + src/ifcparse/IfcSchema.h | 481 +- src/ifcparse/IfcSpfHeader.h | 6 +- src/ifcparse/IfcUtil.cpp | 21 +- src/ifcparse/IfcUtil.h | 63 +- src/ifcparse/IfcWritableEntity.h | 10 +- src/ifcparse/IfcWrite.cpp | 11 +- 38 files changed, 12443 insertions(+), 13645 deletions(-) create mode 100644 src/ifcparse/IfcSchema.cpp diff --git a/src/ifcconvert/SvgSerializer.cpp b/src/ifcconvert/SvgSerializer.cpp index 80b61062b0..0500699522 100644 --- a/src/ifcconvert/SvgSerializer.cpp +++ b/src/ifcconvert/SvgSerializer.cpp @@ -188,7 +188,7 @@ void SvgSerializer::write(const IfcGeom::BRepElement* o) { // Iterate over the decomposing element to find the parent IfcBuildingStorey decomposition_element::list::ptr decomposes = obdef->Decomposes(); if (!decomposes->size()) { - if (obdef->is(IfcSchema::Type::IfcElement)) { + if (obdef->declaration().is(IfcSchema::Type::IfcElement)) { IfcSchema::IfcRelContainedInSpatialStructure::list::ptr containment = ((IfcSchema::IfcElement*)obdef)->ContainedInStructure(); if (!containment->size()) { break; @@ -210,7 +210,7 @@ void SvgSerializer::write(const IfcGeom::BRepElement* o) { } } } - if (obdef->is(IfcSchema::Type::IfcBuildingStorey)) { + if (obdef->declaration().is(IfcSchema::Type::IfcBuildingStorey)) { storey = static_cast(obdef); break; } diff --git a/src/ifcconvert/XmlSerializer.cpp b/src/ifcconvert/XmlSerializer.cpp index 6106078999..7ae2c31c13 100644 --- a/src/ifcconvert/XmlSerializer.cpp +++ b/src/ifcconvert/XmlSerializer.cpp @@ -39,15 +39,15 @@ boost::optional format_attribute(const Argument* argument, IfcUtil: break; } case IfcUtil::Argument_ENTITY_INSTANCE: { IfcUtil::IfcBaseClass* e = *argument; - if (Type::IsSimple(e->type())) { + if (Type::IsSimple(e->declaration().type())) { IfcUtil::IfcBaseType* f = (IfcUtil::IfcBaseType*) e; - value = format_attribute(f->getArgument(0), f->getArgumentType(0)); - } else if (e->is(IfcSchema::Type::IfcSIUnit) || e->is(IfcSchema::Type::IfcConversionBasedUnit)) { + value = format_attribute(f->data().getArgument(0), f->data().getArgument(0)->type()); + } else if (e->declaration().is(IfcSchema::Type::IfcSIUnit) || e->declaration().is(IfcSchema::Type::IfcConversionBasedUnit)) { // Some string concatenation to have a unit name as a XML attribute. std::string unit_name; - if (e->is(IfcSchema::Type::IfcSIUnit)) { + if (e->declaration().is(IfcSchema::Type::IfcSIUnit)) { IfcSchema::IfcSIUnit* unit = (IfcSchema::IfcSIUnit*) e; unit_name = IfcSchema::IfcSIUnitName::ToString(unit->Name()); if (unit->hasPrefix()) { @@ -71,18 +71,20 @@ boost::optional format_attribute(const Argument* argument, IfcUtil: // over the entity attributes and writes them as xml attributes of the node. ptree& format_entity_instance(IfcUtil::IfcBaseEntity* instance, ptree& tree, bool as_link = false) { ptree child; - const unsigned n = instance->getArgumentCount(); + const unsigned n = instance->data().getArgumentCount(); + std::vector attributes = instance->declaration().all_attributes(); + for (unsigned i = 0; i < n; ++i) { - const Argument* argument = instance->getArgument(i); + const Argument* argument = instance->data().getArgument(i); if (argument->isNull()) continue; - std::string argument_name = instance->getArgumentName(i); + std::string argument_name = attributes[i]->name(); std::map::const_iterator argument_name_it; argument_name_it = argument_name_map.find(argument_name); if (argument_name_it != argument_name_map.end()) { argument_name = argument_name_it->second; } - const IfcUtil::ArgumentType argument_type = instance->getArgumentType(i); + const IfcUtil::ArgumentType argument_type = instance->data().getArgument(i)->type(); boost::optional value; try { @@ -101,7 +103,7 @@ ptree& format_entity_instance(IfcUtil::IfcBaseEntity* instance, ptree& tree, boo } } } - return tree.add_child(Type::ToString(instance->type()), child); + return tree.add_child(Type::ToString(instance->declaration().type()), child); } // A function to be called recursively. Template specialization is used @@ -130,7 +132,7 @@ template <> void descend(IfcProduct* product, ptree& tree) { ptree& child = format_entity_instance(product, tree); - if (product->is(Type::IfcSpatialStructureElement)) { + if (product->declaration().is(Type::IfcSpatialStructureElement)) { IfcSpatialStructureElement* structure = (IfcSpatialStructureElement*) product; IfcProduct::list::ptr elements = get_related @@ -154,7 +156,7 @@ void descend(IfcProduct* product, ptree& tree) { for (IfcObjectDefinition::list::it it = structures->begin(); it != structures->end(); ++it) { IfcObjectDefinition* ob = *it; - if (ob->is(Type::IfcSpatialStructureElement)) { + if (ob->declaration().is(Type::IfcSpatialStructureElement)) { descend((IfcProduct*)ob, child); } else { descend(ob, child); @@ -167,7 +169,7 @@ void descend(IfcProduct* product, ptree& tree) { for (IfcPropertySetDefinition::list::it it = property_sets->begin(); it != property_sets->end(); ++it) { IfcPropertySetDefinition* pset = *it; - if (pset->is(Type::IfcPropertySet)) { + if (pset->declaration().is(Type::IfcPropertySet)) { format_entity_instance(pset, child, true); } } @@ -190,7 +192,7 @@ void descend(IfcProject* project, ptree& tree) { for (IfcObjectDefinition::list::it it = structures->begin(); it != structures->end(); ++it) { IfcObjectDefinition* ob = *it; - if (ob->is(Type::IfcSpatialStructureElement)) { + if (ob->declaration().is(Type::IfcSpatialStructureElement)) { descend((IfcProduct*)ob, child); } else { descend(ob, child); @@ -202,7 +204,7 @@ void descend(IfcProject* project, ptree& tree) { void format_properties(IfcProperty::list::ptr properties, ptree& node) { for (IfcProperty::list::it it = properties->begin(); it != properties->end(); ++it) { IfcProperty* p = *it; - if (p->is(Type::IfcComplexProperty)) { + if (p->declaration().is(Type::IfcComplexProperty)) { IfcComplexProperty* complex = (IfcComplexProperty*) p; format_properties(complex->HasProperties(), node); } else { diff --git a/src/ifcexpressparser/implementation.py b/src/ifcexpressparser/implementation.py index f4e0759da3..f574f3f7f5 100644 --- a/src/ifcexpressparser/implementation.py +++ b/src/ifcexpressparser/implementation.py @@ -204,16 +204,20 @@ class Implementation: simple_type_impl.append(templates.simpletype_impl_comment % {'name': class_name}) simple_type_impl.extend(map(compose, map(lambda x: (class_name, attr_type, superclass, "(IfcAbstractEntity*)0")+x, ( - ('getArgumentType', templates.const_function, 'IfcUtil::ArgumentType', ('unsigned int i',), templates.simpletype_impl_argument_type ), - ('getArgument', templates.const_function, 'Argument*', ('unsigned int i',), templates.simpletype_impl_argument ), - ('is', templates.const_function, 'bool', ('Type::Enum v',), simpletype_impl_is ), - ('type', templates.const_function, 'Type::Enum', (), templates.simpletype_impl_type ), + #('getArgumentType', templates.const_function, 'IfcUtil::ArgumentType', ('unsigned int i',), templates.simpletype_impl_argument_type ), + #('getArgument', templates.const_function, 'Argument*', ('unsigned int i',), templates.simpletype_impl_argument ), + #('is', templates.const_function, 'bool', ('Type::Enum v',), simpletype_impl_is ), + #('type', templates.const_function, 'Type::Enum', (), templates.simpletype_impl_type ), ('Class', templates.function, 'Type::Enum', (), templates.simpletype_impl_class ), + ('declaration', templates.const_function, 'const IfcParse::type_declaration&', (), templates.simpletype_impl_declaration ), ('', constructor, '', ('IfcAbstractEntity* e',), templates.simpletype_impl_explicit_constructor), ('', constructor, '', ("%s v" % type_str,), simpletype_impl_constructor ), ('', templates.cast_function, type_str, (), simpletype_impl_cast ) )))) simple_type_impl.append('') + + external_definitions = ["extern entity* %s_type;" % n for n in mapping.schema.entities.keys() ] + \ + ["extern type_declaration* %s_type;" % n for n in mapping.schema.simpletypes.keys()] self.str = templates.implementation % { 'schema_name_upper' : mapping.schema.name.upper(), @@ -226,7 +230,8 @@ class Implementation: 'simple_type_statement' : simple_type_statements, 'parent_type_statements' : catnl(parent_type_statements), 'entity_implementations' : catnl(entity_implementations), - 'simple_type_impl' : catnl(simple_type_impl) + 'simple_type_impl' : catnl(simple_type_impl), + 'external_definitions' : catnl(external_definitions) } self.schema_name = mapping.schema.name.capitalize() diff --git a/src/ifcexpressparser/schema_class.py b/src/ifcexpressparser/schema_class.py index 8cb391e1ed..425b52ee84 100644 --- a/src/ifcexpressparser/schema_class.py +++ b/src/ifcexpressparser/schema_class.py @@ -26,7 +26,10 @@ class SchemaClass: def __init__(self, mapping): class UnmetDependenciesException(Exception): pass - + + schema_name = mapping.schema.name + declared_types = [] + def get_declared_type(type, emitted_names=None): if isinstance(type, nodes.AggregationType): aggr_type = type.aggregate_type @@ -47,7 +50,22 @@ class SchemaClass: self.schema_name = mapping.schema.name.capitalize() - statements = ['','#include "../ifcparse/IfcSchema.h"','','void populate() {'] + statements = ['', + '#include "../ifcparse/IfcSchema.h"', + '', + 'using namespace IfcParse;' + ''] + + collections_by_type = (('entity', mapping.schema.entities ), + ('type_declaration', mapping.schema.simpletypes ), + ('select_type', mapping.schema.selects ), + ('enumeration_type', mapping.schema.enumerations)) + + for cpp_type, collection in collections_by_type: + for name in collection.keys(): + statements.append('%(cpp_type)s* %(name)s_type = 0;' % locals()) + + statements.append('schema_definition* populate_schema() {') emitted_types = set() while len(emitted_types) < len(mapping.schema.simpletypes): @@ -59,16 +77,19 @@ class SchemaClass: except UnmetDependenciesException: continue - statements.append(' declaration* %(name)s_type = new type_declaration("%(name)s", %(declared_type)s);' % locals()) + statements.append(' %(name)s_type = new type_declaration(IfcSchema::Type::%(name)s, %(declared_type)s);' % locals()) emitted_types.add(name) + declared_types.append('%(name)s_type' % locals()) + for name, enum in mapping.schema.enumerations.items(): - statements.append(' declaration* %(name)s_type;' % locals()) statements.append(' {') statements.append(' std::vector items; items.reserve(%d);' % len(enum.values)) statements.extend(map(lambda v: ' items.push_back("%s");' % v, sorted(enum.values))) - statements.append(' %(name)s_type = new enumeration_type("%(name)s", items);' % locals()) + statements.append(' %(name)s_type = new enumeration_type(IfcSchema::Type::%(name)s, items);' % locals()) statements.append(' }') + + declared_types.append('%(name)s_type' % locals()) emitted_entities = set() while len(emitted_entities) < len(mapping.schema.entities): @@ -76,8 +97,10 @@ class SchemaClass: if name in emitted_entities: continue if len(type.supertypes) == 0 or set(type.supertypes) < emitted_entities: supertype = '0' if len(type.supertypes) == 0 else '%s_type' % type.supertypes[0] - statements.append(' entity* %(name)s_type = new entity("%(name)s", %(supertype)s);' % locals()) + statements.append(' %(name)s_type = new entity(IfcSchema::Type::%(name)s, %(supertype)s);' % locals()) emitted_entities.add(name) + + declared_types.append('%(name)s_type' % locals()) emmited = emitted_types | emitted_entities | set(mapping.schema.enumerations.keys()) @@ -86,15 +109,18 @@ class SchemaClass: for name, type in mapping.schema.selects.items(): if name in emitted_selects: continue if set(type.values) < emmited: - statements.append(' declaration* %(name)s_type;' % locals()) statements.append(' {') statements.append(' std::vector items; items.reserve(%d);' % len(type.values)) statements.extend(map(lambda v: ' items.push_back(%s_type);' % v, sorted(type.values))) - statements.append(' %(name)s_type = new select_type("%(name)s", items);' % locals()) + statements.append(' %(name)s_type = new select_type(IfcSchema::Type::%(name)s, items);' % locals()) statements.append(' }') emitted_selects.add(name) emmited.add(name) + declared_types.append('%(name)s_type' % locals()) + + num_declarations = len(declared_types) + for name, type in mapping.schema.entities.items(): derived = set(mapping.derived_in_supertype(type)) attribute_names = list(map(operator.attrgetter('name'), mapping.arguments(type))) @@ -109,8 +135,22 @@ class SchemaClass: statements.append(' ' + " ".join(map(lambda b: 'derived.push_back(%s);' % str(b in derived).lower(), attribute_names))) statements.append(' %(name)s_type->set_attributes(attributes, derived);' % locals()) statements.append(' }') - - statements.extend(('}','','')) + + statements.append('') + statements.append(' std::vector declarations; declarations.reserve(%(num_declarations)d);' % locals()) + for type_name in declared_types: + statements.append(' declarations.push_back(%(type_name)s);' % locals()) + + statements.append(' return new schema_definition("%(schema_name)s", declarations, true);' % locals()) + + statements.extend(('}','')) + + statements.extend(('const schema_definition& get_schema() {', + '', + ' static const schema_definition* s = populate_schema();', + ' return *s;', + '}','','')) + self.str = "\n".join(statements) def __repr__(self): return self.str diff --git a/src/ifcexpressparser/templates.py b/src/ifcexpressparser/templates.py index 2cd9722cd9..c067d9fa2d 100644 --- a/src/ifcexpressparser/templates.py +++ b/src/ifcexpressparser/templates.py @@ -28,9 +28,12 @@ header = """ #include #include "../ifcparse/IfcUtil.h" +#include "../ifcparse/IfcSchema.h" #include "../ifcparse/IfcException.h" #include "../ifcparse/%(schema_name)senum.h" +const IfcParse::schema_definition& get_schema(); + #define IfcSchema %(schema_name)s namespace %(schema_name)s { @@ -103,6 +106,7 @@ namespace Type { implementation= """ #include "../ifcparse/%(schema_name)s.h" +#include "../ifcparse/IfcSchema.h" #include "../ifcparse/IfcException.h" #include "../ifcparse/IfcWrite.h" #include "../ifcparse/IfcWritableEntity.h" @@ -111,6 +115,9 @@ using namespace %(schema_name)s; using namespace IfcParse; using namespace IfcWrite; +// External definitions +%(external_definitions)s + IfcUtil::IfcBaseClass* %(schema_name)s::SchemaEntity(IfcAbstractEntity* e) { switch(e->type()) { %(schema_entity_statements)s @@ -326,10 +333,7 @@ derived_field_statement_attrs = 'idxs.insert(%d); ' simpletype = """%(documentation)s class %(name)s : public %(superclass)s { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit %(name)s (IfcAbstractEntity* e); %(name)s (%(type)s v); @@ -339,16 +343,17 @@ public: simpletype_impl_comment = "// Function implementations for %(name)s" simpletype_impl_argument_type = "if (i == 0) { return %(attr_type)s; } else { throw IfcParse::IfcAttributeOutOfRangeException(\"Argument index out of range\"); }" -simpletype_impl_argument = "return entity->getArgument(i);" +simpletype_impl_argument = "return data_->getArgument(i);" simpletype_impl_is_with_supertype = "return v == Type::%(class_name)s || %(superclass)s::is(v);" simpletype_impl_is_without_supertype = "return v == %(class_name)s::Class();" simpletype_impl_type = "return Type::%(class_name)s;" simpletype_impl_class = "return Type::%(class_name)s;" -simpletype_impl_explicit_constructor = "entity = e;" -simpletype_impl_constructor = "IfcWritableEntity* e = new IfcWritableEntity(Type::%(class_name)s); e->setArgument(0, v); entity = e;" -simpletype_impl_constructor_templated = "IfcWritableEntity* e = new IfcWritableEntity(Type::%(class_name)s); e->setArgument(0, v->generalize()); entity = e;" -simpletype_impl_cast = "return *entity->getArgument(0);" -simpletype_impl_cast_templated = "IfcEntityList::ptr es = *entity->getArgument(0); return es->as<%(underlying_type)s>();" +simpletype_impl_explicit_constructor = "data_ = e;" +simpletype_impl_constructor = "IfcWritableEntity* e = new IfcWritableEntity(Type::%(class_name)s); e->setArgument(0, v); data_ = e;" +simpletype_impl_constructor_templated = "IfcWritableEntity* e = new IfcWritableEntity(Type::%(class_name)s); e->setArgument(0, v->generalize()); data_ = e;" +simpletype_impl_cast = "return *data_->getArgument(0);" +simpletype_impl_cast_templated = "IfcEntityList::ptr es = *data_->getArgument(0); return es->as<%(underlying_type)s>();" +simpletype_impl_declaration = "return *%(class_name)s_type;" select = """%(documentation)s typedef IfcUtil::IfcBaseClass %(name)s; @@ -365,13 +370,7 @@ const char* ToString(%(name)s v); entity = """%(documentation)s class %(name)s %(superclass)s{ public: -%(attributes)s virtual unsigned int getArgumentCount() const { return %(argument_count)d; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const {%(argument_type_function_body)s} - virtual Type::Enum getArgumentEntity(unsigned int i) const {%(argument_entity_function_body)s} - virtual const char* getArgumentName(unsigned int i) const {%(argument_name_function_body)s} - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } -%(inverse)s bool is(Type::Enum v) const; - Type::Enum type() const; +%(attributes)s %(inverse)s virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); %(name)s (IfcAbstractEntity* e); %(name)s (%(constructor_arguments)s); @@ -393,11 +392,12 @@ const char* %(name)s::ToString(%(name)s v) { """ entity_implementation = """// Function implementations for %(name)s -%(attributes)s%(inverse)sbool %(name)s::is(Type::Enum v) const { return v == Type::%(name)s%(parent_type_test)s; } -Type::Enum %(name)s::type() const { return Type::%(name)s; } +%(attributes)s +%(inverse)s +const IfcParse::entity& %(name)s::declaration() const { return *%(name)s_type; } Type::Enum %(name)s::Class() { return Type::%(name)s; } -%(name)s::%(name)s(IfcAbstractEntity* e) : %(superclass)s { if (!e) return; if (!e->is(Type::%(name)s)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -%(name)s::%(name)s(%(constructor_arguments)s) : %(superclass)s { IfcWritableEntity* e = new IfcWritableEntity(Class());%(constructor_implementation)s entity = e; EntityBuffer::Add(this); } +%(name)s::%(name)s(IfcAbstractEntity* e) : %(superclass)s { if (!e) return; if (!e->is(Type::%(name)s)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +%(name)s::%(name)s(%(constructor_arguments)s) : %(superclass)s { IfcWritableEntity* e = new IfcWritableEntity(Class());%(constructor_implementation)s data_ = e; EntityBuffer::Add(this); } """ optional_attribute_description = "/// Whether the optional attribute %s is defined for this %s" @@ -423,19 +423,19 @@ parent_type_stmt = ' if(v==%(name)s%(padding)s) { return %(parent)s; }' parent_type_test = " || %s::is(v)" -optional_attr_stmt = "return !entity->getArgument(%(index)d)->isNull();" +optional_attr_stmt = "return !data_->getArgument(%(index)d)->isNull();" -get_attr_stmt = "return *entity->getArgument(%(index)d);" -get_attr_stmt_enum = "return %(type)s::FromString(*entity->getArgument(%(index)d));" -get_attr_stmt_entity = "return (%(type)s)((IfcUtil::IfcBaseClass*)(*entity->getArgument(%(index)d)));" -get_attr_stmt_array = "IfcEntityList::ptr es = *entity->getArgument(%(index)d); return es->as<%(list_instance_type)s>();" -get_attr_stmt_nested_array = "IfcEntityListList::ptr es = *entity->getArgument(%(index)d); return es->as<%(list_instance_type)s>();" +get_attr_stmt = "return *data_->getArgument(%(index)d);" +get_attr_stmt_enum = "return %(type)s::FromString(*data_->getArgument(%(index)d));" +get_attr_stmt_entity = "return (%(type)s)((IfcUtil::IfcBaseClass*)(*data_->getArgument(%(index)d)));" +get_attr_stmt_array = "IfcEntityList::ptr es = *data_->getArgument(%(index)d); return es->as<%(list_instance_type)s>();" +get_attr_stmt_nested_array = "IfcEntityListList::ptr es = *data_->getArgument(%(index)d); return es->as<%(list_instance_type)s>();" -get_inverse = "return entity->getInverse(Type::%(type)s, %(index)d)->as<%(type)s>();" +get_inverse = "return data_->getInverse(Type::%(type)s, %(index)d)->as<%(type)s>();" -set_attr_stmt = "if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%(index)d,v);" -set_attr_stmt_enum = "if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%(index)d,v,%(type)s::ToString(v));" -set_attr_stmt_array = "if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%(index)d,v->generalize());" +set_attr_stmt = "if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(%(index)d,v);" +set_attr_stmt_enum = "if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(%(index)d,v,%(type)s::ToString(v));" +set_attr_stmt_array = "if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(%(index)d,v->generalize());" constructor_stmt = " e->setArgument(%(index)d,(%(name)s));" constructor_stmt_enum = " e->setArgument(%(index)d,%(name)s,%(type)s::ToString(%(name)s));" diff --git a/src/ifcgeom/IfcGeom.h b/src/ifcgeom/IfcGeom.h index 78d8ded544..88539d7b43 100644 --- a/src/ifcgeom/IfcGeom.h +++ b/src/ifcgeom/IfcGeom.h @@ -46,9 +46,9 @@ #include "../ifcgeom/IfcRepresentationShapeItem.h" #include "../ifcgeom/IfcGeomShapeType.h" -#define IN_CACHE(T,E,t,e) std::map::const_iterator it = cache.T.find(E->entity->id());\ +#define IN_CACHE(T,E,t,e) std::map::const_iterator it = cache.T.find(E->data().id());\ if ( it != cache.T.end() ) { e = it->second; return true; } -#define CACHE(T,E,e) cache.T[E->entity->id()] = e; +#define CACHE(T,E,e) cache.T[E->data().id()] = e; namespace IfcGeom { @@ -140,7 +140,7 @@ public: #ifdef USE_IFC4 IfcEntityList::ptr style_assignments = (*jt)->Styles(); for (IfcEntityList::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) { - if (!(*kt)->is(IfcSchema::Type::IfcPresentationStyleAssignment)) { + if (!(*kt)->declaration().is(IfcSchema::Type::IfcPresentationStyleAssignment)) { continue; } IfcSchema::IfcPresentationStyleAssignment* style_assignment = (IfcSchema::IfcPresentationStyleAssignment*) *kt; @@ -152,12 +152,12 @@ public: IfcEntityList::ptr styles = style_assignment->Styles(); for (IfcEntityList::it lt = styles->begin(); lt != styles->end(); ++lt) { IfcUtil::IfcBaseClass* style = *lt; - if (style->is(IfcSchema::Type::IfcSurfaceStyle)) { + if (style->declaration().is(IfcSchema::Type::IfcSurfaceStyle)) { IfcSchema::IfcSurfaceStyle* surface_style = (IfcSchema::IfcSurfaceStyle*) style; if (surface_style->Side() != IfcSchema::IfcSurfaceSide::IfcSurfaceSide_NEGATIVE) { IfcEntityList::ptr styles_elements = surface_style->Styles(); for (IfcEntityList::it mt = styles_elements->begin(); mt != styles_elements->end(); ++mt) { - if ((*mt)->is(T::Class())) { + if ((*mt)->declaration().is(T::Class())) { return std::make_pair(surface_style, (T*) *mt); } } diff --git a/src/ifcgeom/IfcGeomCurves.cpp b/src/ifcgeom/IfcGeomCurves.cpp index 3d42984299..2b0b1905cb 100644 --- a/src/ifcgeom/IfcGeomCurves.cpp +++ b/src/ifcgeom/IfcGeomCurves.cpp @@ -86,12 +86,12 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircle* l, Handle(Geom_Curve)& curve) { const double r = l->Radius() * getValue(GV_LENGTH_UNIT); if ( r < ALMOST_ZERO ) { - Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l->entity); + Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l); return false; } gp_Trsf trsf; IfcSchema::IfcAxis2Placement* placement = l->Position(); - if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) { + if (placement->declaration().is(IfcSchema::Type::IfcAxis2Placement3D)) { IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf); } else { gp_Trsf2d trsf2d; @@ -106,7 +106,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipse* l, Handle(Geom_Curve) double x = l->SemiAxis1() * getValue(GV_LENGTH_UNIT); double y = l->SemiAxis2() * getValue(GV_LENGTH_UNIT); if (x < ALMOST_ZERO || y < ALMOST_ZERO) { - Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l->entity); + Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l); return false; } // Open Cascade does not allow ellipses of which the minor radius @@ -116,7 +116,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipse* l, Handle(Geom_Curve) const bool rotated = y > x; gp_Trsf trsf; IfcSchema::IfcAxis2Placement* placement = l->Position(); - if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) { + if (placement->declaration().is(IfcSchema::Type::IfcAxis2Placement3D)) { convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf); } else { gp_Trsf2d trsf2d; diff --git a/src/ifcgeom/IfcGeomFaces.cpp b/src/ifcgeom/IfcGeomFaces.cpp index 7adc9eb998..9ae4d974f7 100644 --- a/src/ifcgeom/IfcGeomFaces.cpp +++ b/src/ifcgeom/IfcGeomFaces.cpp @@ -102,7 +102,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) { Handle(Geom_Surface) face_surface; bool reversed_face_surface = false; - const bool is_face_surface = l->is(IfcSchema::Type::IfcFaceSurface); + const bool is_face_surface = l->declaration().is(IfcSchema::Type::IfcFaceSurface); if (is_face_surface) { IfcSchema::IfcFaceSurface* fs = (IfcSchema::IfcFaceSurface*) l; @@ -124,7 +124,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) { for (IfcSchema::IfcFaceBound::list::it it = bounds->begin(); it != bounds->end(); ++it) { IfcSchema::IfcFaceBound* bound = *it; - if (bound->is(IfcSchema::Type::IfcFaceOuterBound)) num_outer_bounds ++; + if (bound->declaration().is(IfcSchema::Type::IfcFaceOuterBound)) num_outer_bounds ++; } // The number of outer bounds should be one according to the schema. Also Open Cascade @@ -132,7 +132,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) { // the face will still be processed as long as there are no holes. A compound of faces // is returned in that case. if (num_bounds > 1 && num_outer_bounds > 1 && num_bounds != num_outer_bounds) { - Logger::Message(Logger::LOG_ERROR, "Invalid configuration of boundaries for:", l->entity); + Logger::Message(Logger::LOG_ERROR, "Invalid configuration of boundaries for:", l); return false; } @@ -156,7 +156,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) { bool same_sense = bound->Orientation(); const bool is_interior = - !bound->is(IfcSchema::Type::IfcFaceOuterBound) && + !bound->declaration().is(IfcSchema::Type::IfcFaceOuterBound) && (num_bounds > 1) && (num_outer_bounds < num_bounds); @@ -168,7 +168,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) { /* The approach below does not result in a significant speed-up - if (loop->is(IfcSchema::Type::IfcPolyLoop) && processed == 0 && face_surface.IsNull()) { + if (loop->declaration().is(IfcSchema::Type::IfcPolyLoop) && processed == 0 && face_surface.IsNull()) { IfcSchema::IfcPolyLoop* polyloop = (IfcSchema::IfcPolyLoop*) loop; IfcSchema::IfcCartesianPoint::list::ptr points = polyloop->Polygon(); @@ -323,7 +323,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangleProfileDef* l, TopoDS const double y = l->YDim() / 2.0f * getValue(GV_LENGTH_UNIT); if ( x < ALMOST_ZERO || y < ALMOST_ZERO ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -339,7 +339,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRoundedRectangleProfileDef* l, const double r = l->RoundingRadius() * getValue(GV_LENGTH_UNIT); if ( x < ALMOST_ZERO || y < ALMOST_ZERO || r < ALMOST_ZERO ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -363,7 +363,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangleHollowProfileDef* l, const double r2 = fr2 ? l->InnerFilletRadius() * getValue(GV_LENGTH_UNIT) : 0.; if ( x < ALMOST_ZERO || y < ALMOST_ZERO ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -405,7 +405,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrapeziumProfileDef* l, TopoDS const double y = l->YDim() / 2.0f * getValue(GV_LENGTH_UNIT); if ( x1 < ALMOST_ZERO || w < ALMOST_ZERO || y < ALMOST_ZERO ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -430,7 +430,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcIShapeProfileDef* l, TopoDS_Sh bool doFillet2 = doFillet1; double x2 = x1, dy2 = dy1, f2 = f1; - if (l->is(IfcSchema::Type::IfcAsymmetricIShapeProfileDef)) { + if (l->declaration().is(IfcSchema::Type::IfcAsymmetricIShapeProfileDef)) { IfcSchema::IfcAsymmetricIShapeProfileDef* assym = (IfcSchema::IfcAsymmetricIShapeProfileDef*) l; x2 = assym->TopFlangeWidth() / 2. * getValue(GV_LENGTH_UNIT); doFillet2 = assym->hasTopFlangeFilletRadius(); @@ -443,7 +443,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcIShapeProfileDef* l, TopoDS_Sh } if ( x1 < ALMOST_ZERO || x2 < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || dy1 < ALMOST_ZERO || dy2 < ALMOST_ZERO ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -476,7 +476,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcZShapeProfileDef* l, TopoDS_Sh } if ( x == 0.0f || y == 0.0f || dx == 0.0f || dy == 0.0f ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -503,7 +503,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCShapeProfileDef* l, TopoDS_Sh } if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -536,7 +536,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcLShapeProfileDef* l, TopoDS_Sh } if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d < ALMOST_ZERO ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -568,7 +568,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcLShapeProfileDef* l, TopoDS_Sh const double det = a1*b2 - a2*b1; if (ALMOST_THE_SAME(det, 0.)) { - Logger::Message(Logger::LOG_NOTICE, "Legs do not intersect for:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Legs do not intersect for:", l); return false; } @@ -614,7 +614,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcUShapeProfileDef* l, TopoDS_Sh } if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -642,7 +642,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTShapeProfileDef* l, TopoDS_Sh const double webSlope = hasWebSlope ? (l->WebSlope() * getValue(GV_PLANEANGLE_UNIT)) : 0.; if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -690,7 +690,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTShapeProfileDef* l, TopoDS_Sh const double det = a1*b2 - a2*b1; if (ALMOST_THE_SAME(det, 0.)) { - Logger::Message(Logger::LOG_NOTICE, "Web and flange do not intersect for:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Web and flange do not intersect for:", l); return false; } @@ -713,7 +713,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTShapeProfileDef* l, TopoDS_Sh bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircleProfileDef* l, TopoDS_Shape& face) { const double r = l->Radius() * getValue(GV_LENGTH_UNIT); if ( r == 0.0f ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -737,7 +737,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircleHollowProfileDef* l, Top const double t = l->WallThickness() * getValue(GV_LENGTH_UNIT); if ( r == 0.0f || t == 0.0f ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } @@ -766,7 +766,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipseProfileDef* l, TopoDS_S double ry = l->SemiAxis2() * getValue(GV_LENGTH_UNIT); if ( rx < ALMOST_ZERO || ry < ALMOST_ZERO ) { - Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity); + Logger::Message(Logger::LOG_NOTICE, "Skipping zero sized profile:", l); return false; } diff --git a/src/ifcgeom/IfcGeomFunctions.cpp b/src/ifcgeom/IfcGeomFunctions.cpp index c8e430283f..842f26444a 100644 --- a/src/ifcgeom/IfcGeomFunctions.cpp +++ b/src/ifcgeom/IfcGeomFunctions.cpp @@ -159,7 +159,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons for ( IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++ it ) { IfcSchema::IfcRelVoidsElement* v = *it; IfcSchema::IfcFeatureElementSubtraction* fes = v->RelatedOpeningElement(); - if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) { + if ( fes->declaration().is(IfcSchema::Type::IfcOpeningElement) ) { // Convert the IfcRepresentation of the IfcOpeningElement gp_Trsf opening_trsf; @@ -190,7 +190,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons const gp_GTrsf& entity_shape_gtrsf = it3->Placement(); TopoDS_Shape entity_shape; if ( entity_shape_gtrsf.Form() == gp_Other ) { - Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to:",entity->entity); + Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to:", entity); entity_shape = BRepBuilderAPI_GTransform(entity_shape_unlocated,entity_shape_gtrsf,true).Shape(); } else { entity_shape = entity_shape_unlocated.Moved(entity_shape_gtrsf.Trsf()); @@ -202,7 +202,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons const TopoDS_Shape& opening_shape_unlocated = ensure_fit_for_subtraction(it4->Shape(),opening_shape_solid); const gp_GTrsf& opening_shape_gtrsf = it4->Placement(); if ( opening_shape_gtrsf.Form() == gp_Other ) { - Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to opening of:",entity->entity); + Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to opening of:", entity); } const TopoDS_Shape& opening_shape = opening_shape_gtrsf.Form() == gp_Other ? BRepBuilderAPI_GTransform(opening_shape_unlocated,opening_shape_gtrsf,true).Shape() @@ -212,7 +212,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons if ( Logger::Verbosity() >= Logger::LOG_WARNING ) { opening_volume = shape_volume(opening_shape); if ( opening_volume <= ALMOST_ZERO ) - Logger::Message(Logger::LOG_WARNING,"Empty opening for:",entity->entity); + Logger::Message(Logger::LOG_WARNING, "Empty opening for:", entity); original_shape_volume = shape_volume(entity_shape); } @@ -246,7 +246,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons // Add the original in case subtraction fails builder.Add(compound, exp.Current()); } else { - Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",entity->entity); + Logger::Message(Logger::LOG_ERROR, "Failed to process subtraction:", entity); } } @@ -263,7 +263,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons fix.Perform(); brep_cut_result = fix.Shape(); } catch (...) { - Logger::Message(Logger::LOG_WARNING, "Shape healing failed on opening subtraction result", entity->entity); + Logger::Message(Logger::LOG_WARNING, "Shape healing failed on opening subtraction result", entity); } BRepCheck_Analyzer analyser(brep_cut_result); @@ -274,13 +274,13 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons const double volume_after_subtraction = shape_volume(entity_shape); if ( ALMOST_THE_SAME(original_shape_volume,volume_after_subtraction) ) - Logger::Message(Logger::LOG_WARNING,"Subtraction yields unchanged volume:",entity->entity); + Logger::Message(Logger::LOG_WARNING, "Subtraction yields unchanged volume:", entity); } } else { - Logger::Message(Logger::LOG_ERROR,"Invalid result from subtraction:",entity->entity); + Logger::Message(Logger::LOG_ERROR, "Invalid result from subtraction:", entity); } } else { - Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",entity->entity); + Logger::Message(Logger::LOG_ERROR, "Failed to process subtraction:", entity); } } @@ -302,7 +302,7 @@ bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity, for ( IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++ it ) { IfcSchema::IfcRelVoidsElement* v = *it; IfcSchema::IfcFeatureElementSubtraction* fes = v->RelatedOpeningElement(); - if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) { + if ( fes->declaration().is(IfcSchema::Type::IfcOpeningElement) ) { // Convert the IfcRepresentation of the IfcOpeningElement gp_Trsf opening_trsf; @@ -339,7 +339,7 @@ bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity, const gp_GTrsf& entity_shape_gtrsf = it3->Placement(); TopoDS_Shape entity_shape; if ( entity_shape_gtrsf.Form() == gp_Other ) { - Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to:",entity->entity); + Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to:", entity); entity_shape = BRepBuilderAPI_GTransform(entity_shape_unlocated,entity_shape_gtrsf,true).Shape(); } else { entity_shape = entity_shape_unlocated.Moved(entity_shape_gtrsf.Trsf()); @@ -360,7 +360,7 @@ bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity, // Apparently processing the boolean operation failed or resulted in an invalid result // in which case the original shape without the subtractions is returned instead // we try convert the openings in the original way, one by one. - Logger::Message(Logger::LOG_WARNING,"Subtracting combined openings compound failed:",entity->entity); + Logger::Message(Logger::LOG_WARNING, "Subtracting combined openings compound failed:", entity); return false; } @@ -855,7 +855,7 @@ IfcGeom::BRepElement

* IfcGeom::Kernel::create_brep_for_representation_and_pro try { IfcSchema::IfcObjectDefinition* parent_object = get_decomposing_entity(product); if (parent_object) { - parent_id = parent_object->entity->id(); + parent_id = parent_object->data().id(); } } catch (...) {} @@ -870,12 +870,12 @@ IfcGeom::BRepElement

* IfcGeom::Kernel::create_brep_for_representation_and_pro // Does the IfcElement have any IfcOpenings? // Note that openings for IfcOpeningElements are not processed IfcSchema::IfcRelVoidsElement::list::ptr openings; - if ( product->is(IfcSchema::Type::IfcElement) && !product->is(IfcSchema::Type::IfcOpeningElement) ) { + if ( product->declaration().is(IfcSchema::Type::IfcElement) && !product->declaration().is(IfcSchema::Type::IfcOpeningElement) ) { IfcSchema::IfcElement* element = (IfcSchema::IfcElement*)product; openings = element->HasOpenings(); } // Is the IfcElement a decomposition of an IfcElement with any IfcOpeningElements? - if ( product->is(IfcSchema::Type::IfcBuildingElementPart ) ) { + if ( product->declaration().is(IfcSchema::Type::IfcBuildingElementPart ) ) { IfcSchema::IfcBuildingElementPart* part = (IfcSchema::IfcBuildingElementPart*)product; #ifdef USE_IFC4 IfcSchema::IfcRelAggregates::list::ptr decomposes = part->Decomposes(); @@ -885,14 +885,14 @@ IfcGeom::BRepElement

* IfcGeom::Kernel::create_brep_for_representation_and_pro for ( IfcSchema::IfcRelDecomposes::list::it it = decomposes->begin(); it != decomposes->end(); ++ it ) { #endif IfcSchema::IfcObjectDefinition* obdef = (*it)->RelatingObject(); - if ( obdef->is(IfcSchema::Type::IfcElement) ) { + if ( obdef->declaration().is(IfcSchema::Type::IfcElement) ) { IfcSchema::IfcElement* element = (IfcSchema::IfcElement*)obdef; openings->push(element->HasOpenings()); } } } - const std::string product_type = IfcSchema::Type::ToString(product->type()); + const std::string product_type = IfcSchema::Type::ToString(product->declaration().type()); ElementSettings element_settings(settings, getValue(GV_LENGTH_UNIT), product_type); if ( !settings.disable_opening_subtractions() && openings && openings->size() ) { @@ -908,7 +908,7 @@ IfcGeom::BRepElement

* IfcGeom::Kernel::create_brep_for_representation_and_pro convert_openings(product,openings,shapes,trsf,opened_shapes); } } catch(...) { - Logger::Message(Logger::LOG_ERROR,"Error processing openings for:",product->entity); + Logger::Message(Logger::LOG_ERROR, "Error processing openings for:", product); } if ( settings.use_world_coords() ) { for ( IfcGeom::IfcRepresentationShapeItems::iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) { @@ -916,15 +916,15 @@ IfcGeom::BRepElement

* IfcGeom::Kernel::create_brep_for_representation_and_pro } trsf = gp_Trsf(); } - shape = new IfcGeom::Representation::BRep(element_settings, representation->entity->id(), opened_shapes); + shape = new IfcGeom::Representation::BRep(element_settings, representation->data().id(), opened_shapes); } else if ( settings.use_world_coords() ) { for ( IfcGeom::IfcRepresentationShapeItems::iterator it = shapes.begin(); it != shapes.end(); ++ it ) { it->prepend(trsf); } trsf = gp_Trsf(); - shape = new IfcGeom::Representation::BRep(element_settings, representation->entity->id(), shapes); + shape = new IfcGeom::Representation::BRep(element_settings, representation->data().id(), shapes); } else { - shape = new IfcGeom::Representation::BRep(element_settings, representation->entity->id(), shapes); + shape = new IfcGeom::Representation::BRep(element_settings, representation->data().id(), shapes); } std::string context_string = ""; @@ -935,7 +935,7 @@ IfcGeom::BRepElement

* IfcGeom::Kernel::create_brep_for_representation_and_pro } return new BRepElement

( - product->entity->id(), + product->data().id(), parent_id, name, product_type, @@ -950,14 +950,14 @@ IfcSchema::IfcObjectDefinition* IfcGeom::Kernel::get_decomposing_entity(IfcSchem IfcSchema::IfcObjectDefinition* parent = 0; // In case of an opening element, parent to the RelatingBuildingElement - if ( product->is(IfcSchema::Type::IfcOpeningElement ) ) { + if ( product->declaration().is(IfcSchema::Type::IfcOpeningElement ) ) { IfcSchema::IfcOpeningElement* opening = (IfcSchema::IfcOpeningElement*)product; IfcSchema::IfcRelVoidsElement::list::ptr voids = opening->VoidsElements(); if ( voids->size() ) { IfcSchema::IfcRelVoidsElement* ifc_void = *voids->begin(); parent = ifc_void->RelatingBuildingElement(); } - } else if ( product->is(IfcSchema::Type::IfcElement ) ) { + } else if ( product->declaration().is(IfcSchema::Type::IfcElement ) ) { IfcSchema::IfcElement* element = (IfcSchema::IfcElement*)product; IfcSchema::IfcRelFillsElement::list::ptr fills = element->FillsVoids(); // Incase of a RelatedBuildingElement parent to the opening element @@ -980,13 +980,13 @@ IfcSchema::IfcObjectDefinition* IfcGeom::Kernel::get_decomposing_entity(IfcSchem } // Parent decompositions to the RelatingObject if (!parent) { - IfcEntityList::ptr parents = product->entity->getInverse(IfcSchema::Type::IfcRelAggregates, -1); - parents->push(product->entity->getInverse(IfcSchema::Type::IfcRelNests, -1)); + IfcEntityList::ptr parents = product->data().getInverse(IfcSchema::Type::IfcRelAggregates, -1); + parents->push(product->data().getInverse(IfcSchema::Type::IfcRelNests, -1)); for ( IfcEntityList::it it = parents->begin(); it != parents->end(); ++ it ) { IfcSchema::IfcRelDecomposes* decompose = (IfcSchema::IfcRelDecomposes*)*it; IfcSchema::IfcObjectDefinition* ifc_objectdef; #ifdef USE_IFC4 - if (decompose->is(IfcSchema::Type::IfcRelAggregates)) { + if (decompose->declaration().is(IfcSchema::Type::IfcRelAggregates)) { ifc_objectdef = ((IfcSchema::IfcRelAggregates*)decompose)->RelatingObject(); } else { continue; @@ -1022,19 +1022,19 @@ std::pair IfcGeom::Kernel::initializeUnits(IfcSchema::IfcUn IfcUtil::IfcBaseClass* base = *it; IfcSchema::IfcSIUnit* unit = 0; double value = 1.f; - if ( base->is(IfcSchema::Type::IfcConversionBasedUnit) ) { + if ( base->declaration().is(IfcSchema::Type::IfcConversionBasedUnit) ) { IfcSchema::IfcConversionBasedUnit* u = (IfcSchema::IfcConversionBasedUnit*)base; current_unit_name = u->Name(); IfcSchema::IfcMeasureWithUnit* u2 = u->ConversionFactor(); IfcSchema::IfcUnit* u3 = u2->UnitComponent(); - if ( u3->is(IfcSchema::Type::IfcSIUnit) ) { + if ( u3->declaration().is(IfcSchema::Type::IfcSIUnit) ) { unit = (IfcSchema::IfcSIUnit*) u3; } IfcSchema::IfcValue* v = u2->ValueComponent(); // Quick hack to get the numeric value from an IfcValue: - const double f = *v->entity->getArgument(0); + const double f = *v->data().getArgument(0); value *= f; - } else if ( base->is(IfcSchema::Type::IfcSIUnit) ) { + } else if ( base->declaration().is(IfcSchema::Type::IfcSIUnit) ) { unit = (IfcSchema::IfcSIUnit*)base; } if ( unit ) { diff --git a/src/ifcgeom/IfcGeomHelpers.cpp b/src/ifcgeom/IfcGeomHelpers.cpp index bba462dd12..932896a95b 100644 --- a/src/ifcgeom/IfcGeomHelpers.cpp +++ b/src/ifcgeom/IfcGeomHelpers.cpp @@ -282,21 +282,21 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcAxis2Placement2D* l, gp_Trsf2d bool IfcGeom::Kernel::convert(const IfcSchema::IfcObjectPlacement* l, gp_Trsf& trsf) { IN_CACHE(IfcObjectPlacement,l,gp_Trsf,trsf) - if ( ! l->is(IfcSchema::Type::IfcLocalPlacement) ) { - Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l->entity); + if ( ! l->declaration().is(IfcSchema::Type::IfcLocalPlacement) ) { + Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l); return false; } IfcSchema::IfcLocalPlacement* current = (IfcSchema::IfcLocalPlacement*)l; while (1) { gp_Trsf trsf2; IfcSchema::IfcAxis2Placement* relplacement = current->RelativePlacement(); - if ( relplacement->is(IfcSchema::Type::IfcAxis2Placement3D) ) { + if ( relplacement->declaration().is(IfcSchema::Type::IfcAxis2Placement3D) ) { IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement3D*)relplacement,trsf2); trsf.PreMultiply(trsf2); } if ( current->hasPlacementRelTo() ) { IfcSchema::IfcObjectPlacement* relto = current->PlacementRelTo(); - if ( relto->is(IfcSchema::Type::IfcLocalPlacement) ) + if ( relto->declaration().is(IfcSchema::Type::IfcLocalPlacement) ) current = (IfcSchema::IfcLocalPlacement*)current->PlacementRelTo(); else break; } else break; diff --git a/src/ifcgeom/IfcGeomIterator.h b/src/ifcgeom/IfcGeomIterator.h index 6c411a4fc5..475fb50509 100644 --- a/src/ifcgeom/IfcGeomIterator.h +++ b/src/ifcgeom/IfcGeomIterator.h @@ -176,7 +176,7 @@ namespace IfcGeom { for (it = contexts->begin(); it != contexts->end(); ++it) { IfcSchema::IfcGeometricRepresentationContext* context = *it; - if (context->is(IfcSchema::Type::IfcGeometricRepresentationSubContext)) { + if (context->declaration().is(IfcSchema::Type::IfcGeometricRepresentationSubContext)) { // Continue, as the list of subcontexts will be considered // by the parent's context inverse attributes. continue; @@ -197,7 +197,7 @@ namespace IfcGeom { if (filtered_contexts->size() == 0) { for (it = contexts->begin(); it != contexts->end(); ++it) { IfcSchema::IfcGeometricRepresentationContext* context = *it; - if (!context->is(IfcSchema::Type::IfcGeometricRepresentationSubContext)) { + if (!context->declaration().is(IfcSchema::Type::IfcGeometricRepresentationSubContext)) { filtered_contexts->push(context); } } @@ -306,7 +306,7 @@ namespace IfcGeom { IfcSchema::IfcProduct::list::ptr unfiltered_products(new IfcSchema::IfcProduct::list); for ( IfcSchema::IfcProductRepresentation::list::it it = prodreps->begin(); it != prodreps->end(); ++it ) { - if ( (*it)->is(IfcSchema::Type::IfcProductDefinitionShape) ) { + if ( (*it)->declaration().is(IfcSchema::Type::IfcProductDefinitionShape) ) { IfcSchema::IfcProductDefinitionShape* pds = (IfcSchema::IfcProductDefinitionShape*)*it; unfiltered_products->push(pds->ShapeOfProduct()); } else { @@ -316,7 +316,7 @@ namespace IfcGeom { // IfcProductRepresentation also lacks the INVERSE relation to IfcProduct // Let's find the IfcProducts that reference the IfcProductRepresentation anyway - unfiltered_products->push((*it)->entity->getInverse(IfcSchema::Type::IfcProduct, -1)->as()); + unfiltered_products->push((*it)->data().getInverse(IfcSchema::Type::IfcProduct, -1)->as()); } // Filter the products based on the set of entities being included or excluded for @@ -324,7 +324,7 @@ namespace IfcGeom { for ( IfcSchema::IfcProduct::list::it it = unfiltered_products->begin(); it != unfiltered_products->end(); ++it ) { bool found = false; for (std::set::const_iterator jt = entities_to_include_or_exclude.begin(); jt != entities_to_include_or_exclude.end(); ++jt) { - if ((*it)->is(*jt)) { + if ((*it)->declaration().is(*jt)) { found = true; break; } @@ -398,7 +398,7 @@ namespace IfcGeom { try { const IfcUtil::IfcBaseClass* ifc_entity = ifc_file->entityById(id); instance_type = IfcSchema::Type::ToString(ifc_entity->type()); - if ( ifc_entity->is(IfcSchema::Type::IfcProduct) ) { + if ( ifc_entity->declaration().is(IfcSchema::Type::IfcProduct) ) { IfcSchema::IfcProduct* ifc_product = (IfcSchema::IfcProduct*)ifc_entity; product_guid = ifc_product->GlobalId(); @@ -408,7 +408,7 @@ namespace IfcGeom { try { IfcSchema::IfcObjectDefinition* parent_object = kernel.get_decomposing_entity(ifc_product); if (parent_object) { - parent_id = parent_object->entity->id(); + parent_id = parent_object->data().id(); } } catch (...) {} diff --git a/src/ifcgeom/IfcGeomRenderStyles.cpp b/src/ifcgeom/IfcGeomRenderStyles.cpp index f8730391d6..b88899cd6c 100644 --- a/src/ifcgeom/IfcGeomRenderStyles.cpp +++ b/src/ifcgeom/IfcGeomRenderStyles.cpp @@ -41,9 +41,9 @@ bool process_colour(IfcSchema::IfcNormalisedRatioMeasure* factor, std::tr1::arra bool process_colour(IfcSchema::IfcColourOrFactor* colour_or_factor, std::tr1::array& rgb) { if (colour_or_factor == 0) { return false; - } else if (colour_or_factor->is(IfcSchema::Type::IfcColourRgb)) { + } else if (colour_or_factor->declaration().is(IfcSchema::Type::IfcColourRgb)) { return process_colour(static_cast(colour_or_factor), rgb); - } else if (colour_or_factor->is(IfcSchema::Type::IfcNormalisedRatioMeasure)) { + } else if (colour_or_factor->declaration().is(IfcSchema::Type::IfcNormalisedRatioMeasure)) { return process_colour(static_cast(colour_or_factor), rgb); } else { return false; @@ -55,7 +55,7 @@ const IfcGeom::SurfaceStyle* IfcGeom::Kernel::get_style(const IfcSchema::IfcRepr if (shading_styles.second == 0) { return 0; } - int surface_style_id = shading_styles.first->entity->id(); + int surface_style_id = shading_styles.first->data().id(); std::map::const_iterator it = cache.Style.find(surface_style_id); if (it != cache.Style.end()) { return &(it->second); @@ -70,7 +70,7 @@ const IfcGeom::SurfaceStyle* IfcGeom::Kernel::get_style(const IfcSchema::IfcRepr if (process_colour(shading_styles.second->SurfaceColour(), rgb)) { surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2])); } - if (shading_styles.second->is(IfcSchema::Type::IfcSurfaceStyleRendering)) { + if (shading_styles.second->declaration().is(IfcSchema::Type::IfcSurfaceStyleRendering)) { IfcSchema::IfcSurfaceStyleRendering* rendering_style = static_cast(shading_styles.second); if (rendering_style->hasDiffuseColour() && process_colour(rendering_style->DiffuseColour(), rgb)) { SurfaceStyle::ColorComponent diffuse = surface_style.Diffuse().get_value_or(SurfaceStyle::ColorComponent(1,1,1)); @@ -87,12 +87,12 @@ const IfcGeom::SurfaceStyle* IfcGeom::Kernel::get_style(const IfcSchema::IfcRepr } if (rendering_style->hasSpecularHighlight()) { IfcSchema::IfcSpecularHighlightSelect* highlight = rendering_style->SpecularHighlight(); - if (highlight->is(IfcSchema::Type::IfcSpecularRoughness)) { + if (highlight->declaration().is(IfcSchema::Type::IfcSpecularRoughness)) { double roughness = *((IfcSchema::IfcSpecularRoughness*)highlight); if (roughness >= 1e-9) { surface_style.Specularity().reset(1.0 / roughness); } - } else if (highlight->is(IfcSchema::Type::IfcSpecularExponent)) { + } else if (highlight->declaration().is(IfcSchema::Type::IfcSpecularExponent)) { surface_style.Specularity().reset(*((IfcSchema::IfcSpecularExponent*)highlight)); } } diff --git a/src/ifcgeom/IfcGeomRepresentation.h b/src/ifcgeom/IfcGeomRepresentation.h index bd7abee278..4448a07b86 100644 --- a/src/ifcgeom/IfcGeomRepresentation.h +++ b/src/ifcgeom/IfcGeomRepresentation.h @@ -148,10 +148,8 @@ namespace IfcGeom { try { BRepMesh_IncrementalMesh(s, settings().deflection_tolerance()); } catch(...) { - // TODO: Catch outside - // Logger::Message(Logger::LOG_ERROR,"Failed to triangulate shape:",ifc_file->entityById(_id)->entity); - Logger::Message(Logger::LOG_ERROR,"Failed to triangulate shape"); + Logger::Message(Logger::LOG_ERROR, "Failed to triangulate shape"); continue; } diff --git a/src/ifcgeom/IfcGeomShapes.cpp b/src/ifcgeom/IfcGeomShapes.cpp index 896863805d..15e5f30f0f 100644 --- a/src/ifcgeom/IfcGeomShapes.cpp +++ b/src/ifcgeom/IfcGeomShapes.cpp @@ -230,8 +230,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFaceBasedSurfaceModel* l, IfcR bool IfcGeom::Kernel::convert(const IfcSchema::IfcHalfSpaceSolid* l, TopoDS_Shape& shape) { IfcSchema::IfcSurface* surface = l->BaseSurface(); - if ( ! surface->is(IfcSchema::Type::IfcPlane) ) { - Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface->entity); + if ( ! surface->declaration().is(IfcSchema::Type::IfcPlane) ) { + Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface); return false; } gp_Pln pln; @@ -261,7 +261,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l, Ifc for( IfcEntityList::it it = shells->begin(); it != shells->end(); ++ it ) { TopoDS_Shape s; const SurfaceStyle* shell_style = 0; - if ((*it)->is(IfcSchema::Type::IfcRepresentationItem)) { + if ((*it)->declaration().is(IfcSchema::Type::IfcRepresentationItem)) { shell_style = get_style((IfcSchema::IfcRepresentationItem*)*it); } if (convert_shape(*it,s)) { @@ -277,7 +277,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape TopoDS_Wire boundary_wire; IfcSchema::IfcBooleanOperand* operand1 = l->FirstOperand(); IfcSchema::IfcBooleanOperand* operand2 = l->SecondOperand(); - bool is_halfspace = operand2->is(IfcSchema::Type::IfcHalfSpaceSolid); + bool is_halfspace = operand2->declaration().is(IfcSchema::Type::IfcHalfSpaceSolid); if ( shape_type(operand1) == ST_SHAPELIST ) { if (!(convert_shapes(operand1, items1) && flatten_shape_list(items1, s1, true))) { @@ -290,13 +290,13 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape { TopoDS_Solid temp_solid; s1 = ensure_fit_for_subtraction(s1, temp_solid); } } else { - Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", operand1->entity); + Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", operand1); return false; } const double first_operand_volume = shape_volume(s1); if ( first_operand_volume <= ALMOST_ZERO ) - Logger::Message(Logger::LOG_WARNING,"Empty solid for:",l->FirstOperand()->entity); + Logger::Message(Logger::LOG_WARNING, "Empty solid for:", l->FirstOperand()); bool shape2_processed = false; if ( shape_type(operand2) == ST_SHAPELIST ) { @@ -308,19 +308,19 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape s2 = ensure_fit_for_subtraction(s2, temp_solid); } } else { - Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", operand2->entity); + Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", operand2); } if (!shape2_processed) { shape = s1; - Logger::Message(Logger::LOG_ERROR,"Failed to convert SecondOperand of:",l->entity); + Logger::Message(Logger::LOG_ERROR, "Failed to convert SecondOperand of:", l); return true; } if (!is_halfspace) { const double second_operand_volume = shape_volume(s2); if ( second_operand_volume <= ALMOST_ZERO ) - Logger::Message(Logger::LOG_WARNING,"Empty solid for:",operand2->entity); + Logger::Message(Logger::LOG_WARNING, "Empty solid for:", operand2); } const IfcSchema::IfcBooleanOperator::IfcBooleanOperator op = l->Operator(); @@ -337,7 +337,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape fix.Perform(); result = fix.Shape(); } catch (...) { - Logger::Message(Logger::LOG_WARNING, "Shape healing failed on boolean result", l->entity); + Logger::Message(Logger::LOG_WARNING, "Shape healing failed on boolean result", l); } bool is_valid = BRepCheck_Analyzer(result).IsValid() != 0; @@ -350,9 +350,9 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape if ( valid_cut ) { const double volume_after_subtraction = shape_volume(shape); if ( ALMOST_THE_SAME(first_operand_volume,volume_after_subtraction) ) - Logger::Message(Logger::LOG_WARNING,"Subtraction yields unchanged volume:",l->entity); + Logger::Message(Logger::LOG_WARNING, "Subtraction yields unchanged volume:", l); } else { - Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",l->entity); + Logger::Message(Logger::LOG_ERROR, "Failed to process subtraction:", l); shape = s1; } @@ -416,7 +416,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh builder.Add(face); facesAdded = true; } else { - Logger::Message(Logger::LOG_WARNING,"Invalid face:",(*it)->entity); + Logger::Message(Logger::LOG_WARNING, "Invalid face:", *it); } } if ( ! facesAdded ) return false; @@ -438,7 +438,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh } } catch(...) {} } else { - Logger::Message(Logger::LOG_WARNING,"Failed to sew faceset:",l->entity); + Logger::Message(Logger::LOG_WARNING, "Failed to sew faceset:", l); } } if (!valid_shell) { @@ -455,7 +455,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh builder.Add(compound,face); facesAdded = true; } else { - Logger::Message(Logger::LOG_WARNING,"Invalid face:",(*it)->entity); + Logger::Message(Logger::LOG_WARNING, "Invalid face:", *it); } } if ( ! facesAdded ) return false; @@ -467,16 +467,16 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh bool IfcGeom::Kernel::convert(const IfcSchema::IfcMappedItem* l, IfcRepresentationShapeItems& shapes) { gp_GTrsf gtrsf; IfcSchema::IfcCartesianTransformationOperator* transform = l->MappingTarget(); - if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3DnonUniform) ) { + if ( transform->declaration().is(IfcSchema::Type::IfcCartesianTransformationOperator3DnonUniform) ) { IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator3DnonUniform*)transform,gtrsf); - } else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2DnonUniform) ) { - Logger::Message(Logger::LOG_ERROR, "Unsupported MappingTarget:", transform->entity); + } else if ( transform->declaration().is(IfcSchema::Type::IfcCartesianTransformationOperator2DnonUniform) ) { + Logger::Message(Logger::LOG_ERROR, "Unsupported MappingTarget:", transform); return false; - } else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3D) ) { + } else if ( transform->declaration().is(IfcSchema::Type::IfcCartesianTransformationOperator3D) ) { gp_Trsf trsf; IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator3D*)transform,trsf); gtrsf = trsf; - } else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2D) ) { + } else if ( transform->declaration().is(IfcSchema::Type::IfcCartesianTransformationOperator2D) ) { gp_Trsf2d trsf_2d; IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator2D*)transform,trsf_2d); gtrsf = (gp_Trsf) trsf_2d; @@ -484,7 +484,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcMappedItem* l, IfcRepresentati IfcSchema::IfcRepresentationMap* map = l->MappingSource(); IfcSchema::IfcAxis2Placement* placement = map->MappingOrigin(); gp_Trsf trsf; - if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) { + if (placement->declaration().is(IfcSchema::Type::IfcAxis2Placement3D)) { IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf); } else { gp_Trsf2d trsf_2d; @@ -531,11 +531,11 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcGeometricSet* l, IfcRepresenta if (convert_shape(element, s)) { part_succes = true; const IfcGeom::SurfaceStyle* style = 0; - if (element->is(IfcSchema::Type::IfcPoint)) { + if (element->declaration().is(IfcSchema::Type::IfcPoint)) { style = get_style((IfcSchema::IfcPoint*) element); - } else if (element->is(IfcSchema::Type::IfcCurve)) { + } else if (element->declaration().is(IfcSchema::Type::IfcCurve)) { style = get_style((IfcSchema::IfcCurve*) element); - } else if (element->is(IfcSchema::Type::IfcSurface)) { + } else if (element->declaration().is(IfcSchema::Type::IfcSurface)) { style = get_style((IfcSchema::IfcSurface*) element); } shapes.push_back(IfcRepresentationShapeItem(s, style ? style : parent_style)); @@ -644,8 +644,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCurveBoundedPlane* l, TopoDS_S } bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangularTrimmedSurface* l, TopoDS_Shape& face) { - if (!l->BasisSurface()->is(IfcSchema::Type::IfcPlane)) { - Logger::Message(Logger::LOG_ERROR, "Unsupported BasisSurface:", l->BasisSurface()->entity); + if (!l->BasisSurface()->declaration().is(IfcSchema::Type::IfcPlane)) { + Logger::Message(Logger::LOG_ERROR, "Unsupported BasisSurface:", l->BasisSurface()); return false; } gp_Pln pln; @@ -663,8 +663,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceCurveSweptAreaSolid* l, TopoDS_Shape face; TopoDS_Wire wire, section; - if (!l->ReferenceSurface()->is(IfcSchema::Type::IfcPlane)) { - Logger::Message(Logger::LOG_WARNING, "Reference surface not supported", l->ReferenceSurface()->entity); + if (!l->ReferenceSurface()->declaration().is(IfcSchema::Type::IfcPlane)) { + Logger::Message(Logger::LOG_WARNING, "Reference surface not supported", l->ReferenceSurface()); return false; } @@ -689,7 +689,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceCurveSweptAreaSolid* l, for (TopExp_Explorer exp(wire, TopAbs_VERTEX); exp.More(); exp.Next()) { if (pln.Distance(BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()))) > ALMOST_ZERO) { directrix_on_plane = false; - Logger::Message(Logger::LOG_WARNING, "The Directrix does not lie on the ReferenceSurface", l->entity); + Logger::Message(Logger::LOG_WARNING, "The Directrix does not lie on the ReferenceSurface", l); break; } } @@ -804,7 +804,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSweptDiskSolid* l, TopoDS_Shap } if (!is_valid) { - Logger::Message(Logger::LOG_WARNING, "Failed to subtract inner radius void for:", l->entity); + Logger::Message(Logger::LOG_WARNING, "Failed to subtract inner radius void for:", l); } } @@ -833,7 +833,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS for (std::vector< std::vector >::const_iterator it = coordinates.begin(); it != coordinates.end(); ++it) { const std::vector& coords = *it; if (coords.size() != 3) { - Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on Coordinates", l->entity); + Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on Coordinates", l); return false; } points.push_back(gp_Pnt(coords[0] * getValue(GV_LENGTH_UNIT), @@ -849,7 +849,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS for(std::vector< std::vector >::const_iterator it = indices.begin(); it != indices.end(); ++ it) { const std::vector& tri = *it; if (tri.size() != 3) { - Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on CoordIndex", l->entity); + Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on CoordIndex", l); return false; } @@ -857,7 +857,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS const int max_index = *std::max_element(tri.begin(), tri.end()); if (min_index < 1 || max_index > points.size()) { - Logger::Message(Logger::LOG_ERROR, "Contents of CoordIndex out of bounds", l->entity); + Logger::Message(Logger::LOG_ERROR, "Contents of CoordIndex out of bounds", l); return false; } @@ -914,7 +914,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS } } catch(...) {} } else { - Logger::Message(Logger::LOG_WARNING, "Failed to sew faceset:", l->entity); + Logger::Message(Logger::LOG_WARNING, "Failed to sew faceset:", l); } } diff --git a/src/ifcgeom/IfcGeomWires.cpp b/src/ifcgeom/IfcGeomWires.cpp index c212ad6422..eb7b086c00 100644 --- a/src/ifcgeom/IfcGeomWires.cpp +++ b/src/ifcgeom/IfcGeomWires.cpp @@ -87,7 +87,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire& wire) { if ( getValue(GV_PLANEANGLE_UNIT)<0 ) { - Logger::Message(Logger::LOG_WARNING,"Creating a composite curve without unit information:",l->entity); + Logger::Message(Logger::LOG_WARNING, "Creating a composite curve without unit information:", l); // Temporarily pretend we do have unit information setValue(GV_PLANEANGLE_UNIT,1.0); @@ -148,7 +148,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire IfcSchema::IfcCurve* curve = (*it)->ParentCurve(); TopoDS_Wire wire2; if ( !convert_wire(curve,wire2) ) { - Logger::Message(Logger::LOG_ERROR,"Failed to convert curve:",curve->entity); + Logger::Message(Logger::LOG_ERROR, "Failed to convert curve:", curve); continue; } if ( ! (*it)->SameSense() ) wire2.Reverse(); @@ -167,7 +167,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire w.Add(wire2); //last_vertex = w.Vertex(); if ( w.Error() != BRepBuilderAPI_WireDone ) { - Logger::Message(Logger::LOG_ERROR,"Failed to join curve segments:",l->entity); + Logger::Message(Logger::LOG_ERROR, "Failed to join curve segments:", l); return false; } } @@ -177,7 +177,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire& wire) { IfcSchema::IfcCurve* basis_curve = l->BasisCurve(); - bool isConic = basis_curve->is(IfcSchema::Type::IfcConic); + bool isConic = basis_curve->declaration().is(IfcSchema::Type::IfcConic); double parameterFactor = isConic ? getValue(GV_PLANEANGLE_UNIT) : getValue(GV_LENGTH_UNIT); Handle(Geom_Curve) curve; if ( !convert_curve(basis_curve,curve) ) return false; @@ -194,10 +194,10 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire& BRepBuilderAPI_MakeWire w; for ( IfcEntityList::it it = trims1->begin(); it != trims1->end(); it ++ ) { IfcUtil::IfcBaseClass* i = *it; - if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) { + if ( i->declaration().is(IfcSchema::Type::IfcCartesianPoint) ) { IfcGeom::Kernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[sense_agreement] ); has_pnts[sense_agreement] = true; - } else if ( i->is(IfcSchema::Type::IfcParameterValue) ) { + } else if ( i->declaration().is(IfcSchema::Type::IfcParameterValue) ) { const double value = *((IfcSchema::IfcParameterValue*)i); flts[sense_agreement] = value * parameterFactor; has_flts[sense_agreement] = true; @@ -205,10 +205,10 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire& } for ( IfcEntityList::it it = trims2->begin(); it != trims2->end(); it ++ ) { IfcUtil::IfcBaseClass* i = *it; - if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) { + if ( i->declaration().is(IfcSchema::Type::IfcCartesianPoint) ) { IfcGeom::Kernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[1-sense_agreement] ); has_pnts[1-sense_agreement] = true; - } else if ( i->is(IfcSchema::Type::IfcParameterValue) ) { + } else if ( i->declaration().is(IfcSchema::Type::IfcParameterValue) ) { const double value = *((IfcSchema::IfcParameterValue*)i); flts[1-sense_agreement] = value * parameterFactor; has_flts[1-sense_agreement] = true; @@ -218,7 +218,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire& bool trim_cartesian_failed = !trim_cartesian; if ( trim_cartesian ) { if ( pnts[0].Distance(pnts[1]) < getValue(GV_WIRE_CREATION_TOLERANCE) ) { - Logger::Message(Logger::LOG_WARNING,"Skipping segment with length below tolerance level:",l->entity); + Logger::Message(Logger::LOG_WARNING, "Skipping segment with length below tolerance level:", l); return false; } ShapeFix_ShapeTolerance FTol; @@ -230,7 +230,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire& if ( ! e.IsDone() ) { BRepBuilderAPI_EdgeError err = e.Error(); if ( err == BRepBuilderAPI_PointProjectionFailed ) { - Logger::Message(Logger::LOG_WARNING,"Point projection failed for:",l->entity); + Logger::Message(Logger::LOG_WARNING, "Point projection failed for:", l); trim_cartesian_failed = true; } } else { @@ -242,12 +242,12 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire& // is defined by an IfcCartesianPoint and an IfcVector with Magnitude. Because // the vector is normalised when passed to Geom_Line constructor the magnitude // needs to be factored in with the IfcParameterValue here. - if ( basis_curve->is(IfcSchema::Type::IfcLine) ) { + if ( basis_curve->declaration().is(IfcSchema::Type::IfcLine) ) { IfcSchema::IfcLine* line = static_cast(basis_curve); const double magnitude = line->Dir()->Magnitude(); flts[0] *= magnitude; flts[1] *= magnitude; } - if ( basis_curve->is(IfcSchema::Type::IfcEllipse) ) { + if ( basis_curve->declaration().is(IfcSchema::Type::IfcEllipse) ) { IfcSchema::IfcEllipse* ellipse = static_cast(basis_curve); double x = ellipse->SemiAxis1() * getValue(GV_LENGTH_UNIT); double y = ellipse->SemiAxis2() * getValue(GV_LENGTH_UNIT); @@ -311,7 +311,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolyLoop* l, TopoDS_Wire& resu // A loop should consist of at least three vertices int original_count = polygon.Length(); if (original_count < 3) { - Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l->entity); + Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l); return false; } @@ -321,11 +321,11 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolyLoop* l, TopoDS_Wire& resu int count = polygon.Length(); if (original_count - count != 0) { std::stringstream ss; ss << (original_count - count) << " edges removed for:"; - Logger::Message(Logger::LOG_WARNING, ss.str(), l->entity); + Logger::Message(Logger::LOG_WARNING, ss.str(), l); } if (count < 3) { - Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l->entity); + Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l); return false; } @@ -346,8 +346,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcArbitraryOpenProfileDef* l, To bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdgeCurve* l, TopoDS_Wire& result) { IfcSchema::IfcPoint* pnt1 = ((IfcSchema::IfcVertexPoint*) l->EdgeStart())->VertexGeometry(); IfcSchema::IfcPoint* pnt2 = ((IfcSchema::IfcVertexPoint*) l->EdgeEnd())->VertexGeometry(); - if (!pnt1->is(IfcSchema::Type::IfcCartesianPoint) || !pnt2->is(IfcSchema::Type::IfcCartesianPoint)) { - Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l->entity); + if (!pnt1->declaration().is(IfcSchema::Type::IfcCartesianPoint) || !pnt2->declaration().is(IfcSchema::Type::IfcCartesianPoint)) { + Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l); return false; } @@ -366,7 +366,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdgeCurve* l, TopoDS_Wire& res // assumed that a topological wire can be crafted from it. After which an // attempt is made to reconstruct it from the individual curves and the vertices // of the IfcEdgeCurve. - const bool is_bounded = l->EdgeGeometry()->is(IfcSchema::Type::IfcBoundedCurve); + const bool is_bounded = l->EdgeGeometry()->declaration().is(IfcSchema::Type::IfcBoundedCurve); if (!is_bounded && convert_curve(l->EdgeGeometry(), crv)) { mw.Add(BRepBuilderAPI_MakeEdge(crv, p1, p2)); @@ -424,15 +424,15 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdgeLoop* l, TopoDS_Wire& resu } bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdge* l, TopoDS_Wire& result) { - if (!l->EdgeStart()->is(IfcSchema::Type::IfcVertexPoint) || !l->EdgeEnd()->is(IfcSchema::Type::IfcVertexPoint)) { - Logger::Message(Logger::LOG_ERROR, "Only IfcVertexPoints are supported for EdgeStart and -End", l->entity); + if (!l->EdgeStart()->declaration().is(IfcSchema::Type::IfcVertexPoint) || !l->EdgeEnd()->declaration().is(IfcSchema::Type::IfcVertexPoint)) { + Logger::Message(Logger::LOG_ERROR, "Only IfcVertexPoints are supported for EdgeStart and -End", l); return false; } IfcSchema::IfcPoint* pnt1 = ((IfcSchema::IfcVertexPoint*) l->EdgeStart())->VertexGeometry(); IfcSchema::IfcPoint* pnt2 = ((IfcSchema::IfcVertexPoint*) l->EdgeEnd())->VertexGeometry(); - if (!pnt1->is(IfcSchema::Type::IfcCartesianPoint) || !pnt2->is(IfcSchema::Type::IfcCartesianPoint)) { - Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l->entity); + if (!pnt1->declaration().is(IfcSchema::Type::IfcCartesianPoint) || !pnt2->declaration().is(IfcSchema::Type::IfcCartesianPoint)) { + Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l); return false; } diff --git a/src/ifcgeom/IfcRegister.cpp b/src/ifcgeom/IfcRegister.cpp index e00654da5d..5a639f96dc 100644 --- a/src/ifcgeom/IfcRegister.cpp +++ b/src/ifcgeom/IfcRegister.cpp @@ -25,7 +25,7 @@ using namespace IfcUtil; bool IfcGeom::Kernel::convert_shapes(const IfcBaseClass* l, IfcRepresentationShapeItems& r) { #include "IfcRegisterConvertShapes.h" - Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity); + Logger::Message(Logger::LOG_ERROR, "No operation defined for:", l); return false; } @@ -35,7 +35,7 @@ IfcGeom::ShapeType IfcGeom::Kernel::shape_type(const IfcBaseClass* l) { } bool IfcGeom::Kernel::convert_shape(const IfcBaseClass* l, TopoDS_Shape& r) { - const unsigned int id = l->entity->id(); + const unsigned int id = l->data().id(); bool success = false; bool processed = false; bool ignored = false; @@ -81,7 +81,7 @@ bool IfcGeom::Kernel::convert_shape(const IfcBaseClass* l, TopoDS_Shape& r) { const char* const msg = processed ? "Failed to convert:" : "No operation defined for:"; - Logger::Message(Logger::LOG_ERROR, msg, l->entity); + Logger::Message(Logger::LOG_ERROR, msg, l); } return success; } @@ -92,18 +92,18 @@ bool IfcGeom::Kernel::convert_wire(const IfcBaseClass* l, TopoDS_Wire& r) { if (IfcGeom::Kernel::convert_curve(l, curve)) { return IfcGeom::Kernel::convert_curve_to_wire(curve, r); } - Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity); + Logger::Message(Logger::LOG_ERROR, "No operation defined for:", l); return false; } bool IfcGeom::Kernel::convert_face(const IfcBaseClass* l, TopoDS_Shape& r) { #include "IfcRegisterConvertFace.h" - Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity); + Logger::Message(Logger::LOG_ERROR, "No operation defined for:", l); return false; } bool IfcGeom::Kernel::convert_curve(const IfcBaseClass* l, Handle(Geom_Curve)& r) { #include "IfcRegisterConvertCurve.h" - Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity); + Logger::Message(Logger::LOG_ERROR, "No operation defined for:", l); return false; } \ No newline at end of file diff --git a/src/ifcgeom/IfcRegisterConvertCurve.h b/src/ifcgeom/IfcRegisterConvertCurve.h index e67aa45807..5e33fb18df 100644 --- a/src/ifcgeom/IfcRegisterConvertCurve.h +++ b/src/ifcgeom/IfcRegisterConvertCurve.h @@ -1,6 +1,6 @@ #include "IfcRegisterUndef.h" #define CURVE(T) \ - if ( l->is(T::Class()) ) return convert((T*)l,r); + if ( l->declaration().is(T::Class()) ) return convert(l->as(), r); #include "IfcRegisterDef.h" #include "IfcRegister.h" \ No newline at end of file diff --git a/src/ifcgeom/IfcRegisterConvertFace.h b/src/ifcgeom/IfcRegisterConvertFace.h index 04d524d315..c51e134c4a 100644 --- a/src/ifcgeom/IfcRegisterConvertFace.h +++ b/src/ifcgeom/IfcRegisterConvertFace.h @@ -1,6 +1,6 @@ #include "IfcRegisterUndef.h" #define FACE(T) \ - if ( l->is(T::Class()) ) return convert((T*)l,r); + if ( l->declaration().is(T::Class()) ) return convert(l->as(), r); #include "IfcRegisterDef.h" #include "IfcRegister.h" \ No newline at end of file diff --git a/src/ifcgeom/IfcRegisterConvertShape.h b/src/ifcgeom/IfcRegisterConvertShape.h index 192776555d..e2deb2e1cd 100644 --- a/src/ifcgeom/IfcRegisterConvertShape.h +++ b/src/ifcgeom/IfcRegisterConvertShape.h @@ -1,14 +1,14 @@ #include "IfcRegisterUndef.h" #define SHAPE(T) \ - if ( !processed && l->is(T::Class()) ) { \ + if ( !processed && l->declaration().is(T::Class()) ) { \ processed = true; \ try { \ - if ( convert((T*)l,r) ) { \ + if ( convert(l->as(), r) ) { \ success = true; \ } \ } catch(...) { } \ if ( !success) { \ - Logger::Message(Logger::LOG_ERROR,"Failed to convert:",l->entity); \ + Logger::Message(Logger::LOG_ERROR, "Failed to convert:", l); \ return false; \ } \ } diff --git a/src/ifcgeom/IfcRegisterConvertShapes.h b/src/ifcgeom/IfcRegisterConvertShapes.h index 9da7ff1263..18e32bf199 100644 --- a/src/ifcgeom/IfcRegisterConvertShapes.h +++ b/src/ifcgeom/IfcRegisterConvertShapes.h @@ -1,10 +1,10 @@ #include "IfcRegisterUndef.h" #define SHAPES(T) \ - if ( l->is(T::Class()) ) { \ + if ( l->declaration().is(T::Class()) ) { \ try { \ - return convert((T*)l,r); \ + return convert(l->as(), r); \ } catch (...) { } \ - Logger::Message(Logger::LOG_ERROR,"Failed to convert:",l->entity); \ + Logger::Message(Logger::LOG_ERROR, "Failed to convert:", l); \ return false; \ } #include "IfcRegisterDef.h" diff --git a/src/ifcgeom/IfcRegisterConvertWire.h b/src/ifcgeom/IfcRegisterConvertWire.h index cd914b5c81..309ea0b19c 100644 --- a/src/ifcgeom/IfcRegisterConvertWire.h +++ b/src/ifcgeom/IfcRegisterConvertWire.h @@ -1,6 +1,6 @@ #include "IfcRegisterUndef.h" #define WIRE(T) \ - if ( l->is(T::Class()) ) return convert((T*)l,r); + if ( l->declaration().is(T::Class()) ) return convert((T*)l,r); #include "IfcRegisterDef.h" #include "IfcRegister.h" \ No newline at end of file diff --git a/src/ifcgeom/IfcRegisterShapeType.h b/src/ifcgeom/IfcRegisterShapeType.h index d11d64c9b0..768a3809d6 100644 --- a/src/ifcgeom/IfcRegisterShapeType.h +++ b/src/ifcgeom/IfcRegisterShapeType.h @@ -1,14 +1,14 @@ #include "IfcRegisterUndef.h" #define SHAPES(T) \ - if ( l->is(T::Class()) ) return ST_SHAPELIST; + if ( l->declaration().is(T::Class()) ) return ST_SHAPELIST; #define SHAPE(T) \ - if ( l->is(T::Class()) ) return ST_SHAPE; + if ( l->declaration().is(T::Class()) ) return ST_SHAPE; #define WIRE(T) \ - if ( l->is(T::Class()) ) return ST_WIRE; + if ( l->declaration().is(T::Class()) ) return ST_WIRE; #define FACE(T) \ - if ( l->is(T::Class()) ) return ST_FACE; + if ( l->declaration().is(T::Class()) ) return ST_FACE; #define CURVE(T) \ - if ( l->is(T::Class()) ) return ST_CURVE; + if ( l->declaration().is(T::Class()) ) return ST_CURVE; #include "IfcRegisterDef.h" #include "IfcRegister.h" \ No newline at end of file diff --git a/src/ifcparse/Ifc2x3-schema.cpp b/src/ifcparse/Ifc2x3-schema.cpp index 9dcc7d315c..0eb17076e5 100644 --- a/src/ifcparse/Ifc2x3-schema.cpp +++ b/src/ifcparse/Ifc2x3-schema.cpp @@ -28,125 +28,1105 @@ #include "../ifcparse/IfcSchema.h" -void populate() { - declaration* IfcAbsorbedDoseMeasure_type = new type_declaration("IfcAbsorbedDoseMeasure", new simple_type(simple_type::real_type)); - declaration* IfcAccelerationMeasure_type = new type_declaration("IfcAccelerationMeasure", new simple_type(simple_type::real_type)); - declaration* IfcAmountOfSubstanceMeasure_type = new type_declaration("IfcAmountOfSubstanceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcAngularVelocityMeasure_type = new type_declaration("IfcAngularVelocityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcAreaMeasure_type = new type_declaration("IfcAreaMeasure", new simple_type(simple_type::real_type)); - declaration* IfcBoolean_type = new type_declaration("IfcBoolean", new simple_type(simple_type::boolean_type)); - declaration* IfcComplexNumber_type = new type_declaration("IfcComplexNumber", new aggregation_type(aggregation_type::array_type, 1, 2, new simple_type(simple_type::real_type))); - declaration* IfcCompoundPlaneAngleMeasure_type = new type_declaration("IfcCompoundPlaneAngleMeasure", new aggregation_type(aggregation_type::list_type, 3, 4, new simple_type(simple_type::integer_type))); - declaration* IfcContextDependentMeasure_type = new type_declaration("IfcContextDependentMeasure", new simple_type(simple_type::real_type)); - declaration* IfcCountMeasure_type = new type_declaration("IfcCountMeasure", new simple_type(simple_type::number_type)); - declaration* IfcCurvatureMeasure_type = new type_declaration("IfcCurvatureMeasure", new simple_type(simple_type::real_type)); - declaration* IfcDayInMonthNumber_type = new type_declaration("IfcDayInMonthNumber", new simple_type(simple_type::integer_type)); - declaration* IfcDaylightSavingHour_type = new type_declaration("IfcDaylightSavingHour", new simple_type(simple_type::integer_type)); - declaration* IfcDescriptiveMeasure_type = new type_declaration("IfcDescriptiveMeasure", new simple_type(simple_type::string_type)); - declaration* IfcDimensionCount_type = new type_declaration("IfcDimensionCount", new simple_type(simple_type::integer_type)); - declaration* IfcDoseEquivalentMeasure_type = new type_declaration("IfcDoseEquivalentMeasure", new simple_type(simple_type::real_type)); - declaration* IfcDynamicViscosityMeasure_type = new type_declaration("IfcDynamicViscosityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcElectricCapacitanceMeasure_type = new type_declaration("IfcElectricCapacitanceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcElectricChargeMeasure_type = new type_declaration("IfcElectricChargeMeasure", new simple_type(simple_type::real_type)); - declaration* IfcElectricConductanceMeasure_type = new type_declaration("IfcElectricConductanceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcElectricCurrentMeasure_type = new type_declaration("IfcElectricCurrentMeasure", new simple_type(simple_type::real_type)); - declaration* IfcElectricResistanceMeasure_type = new type_declaration("IfcElectricResistanceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcElectricVoltageMeasure_type = new type_declaration("IfcElectricVoltageMeasure", new simple_type(simple_type::real_type)); - declaration* IfcEnergyMeasure_type = new type_declaration("IfcEnergyMeasure", new simple_type(simple_type::real_type)); - declaration* IfcFontStyle_type = new type_declaration("IfcFontStyle", new simple_type(simple_type::string_type)); - declaration* IfcFontVariant_type = new type_declaration("IfcFontVariant", new simple_type(simple_type::string_type)); - declaration* IfcFontWeight_type = new type_declaration("IfcFontWeight", new simple_type(simple_type::string_type)); - declaration* IfcForceMeasure_type = new type_declaration("IfcForceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcFrequencyMeasure_type = new type_declaration("IfcFrequencyMeasure", new simple_type(simple_type::real_type)); - declaration* IfcGloballyUniqueId_type = new type_declaration("IfcGloballyUniqueId", new simple_type(simple_type::string_type)); - declaration* IfcHeatFluxDensityMeasure_type = new type_declaration("IfcHeatFluxDensityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcHeatingValueMeasure_type = new type_declaration("IfcHeatingValueMeasure", new simple_type(simple_type::real_type)); - declaration* IfcHourInDay_type = new type_declaration("IfcHourInDay", new simple_type(simple_type::integer_type)); - declaration* IfcIdentifier_type = new type_declaration("IfcIdentifier", new simple_type(simple_type::string_type)); - declaration* IfcIlluminanceMeasure_type = new type_declaration("IfcIlluminanceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcInductanceMeasure_type = new type_declaration("IfcInductanceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcInteger_type = new type_declaration("IfcInteger", new simple_type(simple_type::integer_type)); - declaration* IfcIntegerCountRateMeasure_type = new type_declaration("IfcIntegerCountRateMeasure", new simple_type(simple_type::integer_type)); - declaration* IfcIonConcentrationMeasure_type = new type_declaration("IfcIonConcentrationMeasure", new simple_type(simple_type::real_type)); - declaration* IfcIsothermalMoistureCapacityMeasure_type = new type_declaration("IfcIsothermalMoistureCapacityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcKinematicViscosityMeasure_type = new type_declaration("IfcKinematicViscosityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcLabel_type = new type_declaration("IfcLabel", new simple_type(simple_type::string_type)); - declaration* IfcLengthMeasure_type = new type_declaration("IfcLengthMeasure", new simple_type(simple_type::real_type)); - declaration* IfcLinearForceMeasure_type = new type_declaration("IfcLinearForceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcLinearMomentMeasure_type = new type_declaration("IfcLinearMomentMeasure", new simple_type(simple_type::real_type)); - declaration* IfcLinearStiffnessMeasure_type = new type_declaration("IfcLinearStiffnessMeasure", new simple_type(simple_type::real_type)); - declaration* IfcLinearVelocityMeasure_type = new type_declaration("IfcLinearVelocityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcLogical_type = new type_declaration("IfcLogical", new simple_type(simple_type::logical_type)); - declaration* IfcLuminousFluxMeasure_type = new type_declaration("IfcLuminousFluxMeasure", new simple_type(simple_type::real_type)); - declaration* IfcLuminousIntensityDistributionMeasure_type = new type_declaration("IfcLuminousIntensityDistributionMeasure", new simple_type(simple_type::real_type)); - declaration* IfcLuminousIntensityMeasure_type = new type_declaration("IfcLuminousIntensityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMagneticFluxDensityMeasure_type = new type_declaration("IfcMagneticFluxDensityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMagneticFluxMeasure_type = new type_declaration("IfcMagneticFluxMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMassDensityMeasure_type = new type_declaration("IfcMassDensityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMassFlowRateMeasure_type = new type_declaration("IfcMassFlowRateMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMassMeasure_type = new type_declaration("IfcMassMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMassPerLengthMeasure_type = new type_declaration("IfcMassPerLengthMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMinuteInHour_type = new type_declaration("IfcMinuteInHour", new simple_type(simple_type::integer_type)); - declaration* IfcModulusOfElasticityMeasure_type = new type_declaration("IfcModulusOfElasticityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcModulusOfLinearSubgradeReactionMeasure_type = new type_declaration("IfcModulusOfLinearSubgradeReactionMeasure", new simple_type(simple_type::real_type)); - declaration* IfcModulusOfRotationalSubgradeReactionMeasure_type = new type_declaration("IfcModulusOfRotationalSubgradeReactionMeasure", new simple_type(simple_type::real_type)); - declaration* IfcModulusOfSubgradeReactionMeasure_type = new type_declaration("IfcModulusOfSubgradeReactionMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMoistureDiffusivityMeasure_type = new type_declaration("IfcMoistureDiffusivityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMolecularWeightMeasure_type = new type_declaration("IfcMolecularWeightMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMomentOfInertiaMeasure_type = new type_declaration("IfcMomentOfInertiaMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMonetaryMeasure_type = new type_declaration("IfcMonetaryMeasure", new simple_type(simple_type::real_type)); - declaration* IfcMonthInYearNumber_type = new type_declaration("IfcMonthInYearNumber", new simple_type(simple_type::integer_type)); - declaration* IfcNumericMeasure_type = new type_declaration("IfcNumericMeasure", new simple_type(simple_type::number_type)); - declaration* IfcPHMeasure_type = new type_declaration("IfcPHMeasure", new simple_type(simple_type::real_type)); - declaration* IfcParameterValue_type = new type_declaration("IfcParameterValue", new simple_type(simple_type::real_type)); - declaration* IfcPlanarForceMeasure_type = new type_declaration("IfcPlanarForceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcPlaneAngleMeasure_type = new type_declaration("IfcPlaneAngleMeasure", new simple_type(simple_type::real_type)); - declaration* IfcPositiveLengthMeasure_type = new type_declaration("IfcPositiveLengthMeasure", new named_type(IfcLengthMeasure_type)); - declaration* IfcPositivePlaneAngleMeasure_type = new type_declaration("IfcPositivePlaneAngleMeasure", new named_type(IfcPlaneAngleMeasure_type)); - declaration* IfcPowerMeasure_type = new type_declaration("IfcPowerMeasure", new simple_type(simple_type::real_type)); - declaration* IfcPresentableText_type = new type_declaration("IfcPresentableText", new simple_type(simple_type::string_type)); - declaration* IfcPressureMeasure_type = new type_declaration("IfcPressureMeasure", new simple_type(simple_type::real_type)); - declaration* IfcRadioActivityMeasure_type = new type_declaration("IfcRadioActivityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcRatioMeasure_type = new type_declaration("IfcRatioMeasure", new simple_type(simple_type::real_type)); - declaration* IfcReal_type = new type_declaration("IfcReal", new simple_type(simple_type::real_type)); - declaration* IfcRotationalFrequencyMeasure_type = new type_declaration("IfcRotationalFrequencyMeasure", new simple_type(simple_type::real_type)); - declaration* IfcRotationalMassMeasure_type = new type_declaration("IfcRotationalMassMeasure", new simple_type(simple_type::real_type)); - declaration* IfcRotationalStiffnessMeasure_type = new type_declaration("IfcRotationalStiffnessMeasure", new simple_type(simple_type::real_type)); - declaration* IfcSecondInMinute_type = new type_declaration("IfcSecondInMinute", new simple_type(simple_type::real_type)); - declaration* IfcSectionModulusMeasure_type = new type_declaration("IfcSectionModulusMeasure", new simple_type(simple_type::real_type)); - declaration* IfcSectionalAreaIntegralMeasure_type = new type_declaration("IfcSectionalAreaIntegralMeasure", new simple_type(simple_type::real_type)); - declaration* IfcShearModulusMeasure_type = new type_declaration("IfcShearModulusMeasure", new simple_type(simple_type::real_type)); - declaration* IfcSolidAngleMeasure_type = new type_declaration("IfcSolidAngleMeasure", new simple_type(simple_type::real_type)); - declaration* IfcSoundPowerMeasure_type = new type_declaration("IfcSoundPowerMeasure", new simple_type(simple_type::real_type)); - declaration* IfcSoundPressureMeasure_type = new type_declaration("IfcSoundPressureMeasure", new simple_type(simple_type::real_type)); - declaration* IfcSpecificHeatCapacityMeasure_type = new type_declaration("IfcSpecificHeatCapacityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcSpecularExponent_type = new type_declaration("IfcSpecularExponent", new simple_type(simple_type::real_type)); - declaration* IfcSpecularRoughness_type = new type_declaration("IfcSpecularRoughness", new simple_type(simple_type::real_type)); - declaration* IfcTemperatureGradientMeasure_type = new type_declaration("IfcTemperatureGradientMeasure", new simple_type(simple_type::real_type)); - declaration* IfcText_type = new type_declaration("IfcText", new simple_type(simple_type::string_type)); - declaration* IfcTextAlignment_type = new type_declaration("IfcTextAlignment", new simple_type(simple_type::string_type)); - declaration* IfcTextDecoration_type = new type_declaration("IfcTextDecoration", new simple_type(simple_type::string_type)); - declaration* IfcTextFontName_type = new type_declaration("IfcTextFontName", new simple_type(simple_type::string_type)); - declaration* IfcTextTransformation_type = new type_declaration("IfcTextTransformation", new simple_type(simple_type::string_type)); - declaration* IfcThermalAdmittanceMeasure_type = new type_declaration("IfcThermalAdmittanceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcThermalConductivityMeasure_type = new type_declaration("IfcThermalConductivityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcThermalExpansionCoefficientMeasure_type = new type_declaration("IfcThermalExpansionCoefficientMeasure", new simple_type(simple_type::real_type)); - declaration* IfcThermalResistanceMeasure_type = new type_declaration("IfcThermalResistanceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcThermalTransmittanceMeasure_type = new type_declaration("IfcThermalTransmittanceMeasure", new simple_type(simple_type::real_type)); - declaration* IfcThermodynamicTemperatureMeasure_type = new type_declaration("IfcThermodynamicTemperatureMeasure", new simple_type(simple_type::real_type)); - declaration* IfcTimeMeasure_type = new type_declaration("IfcTimeMeasure", new simple_type(simple_type::real_type)); - declaration* IfcTimeStamp_type = new type_declaration("IfcTimeStamp", new simple_type(simple_type::integer_type)); - declaration* IfcTorqueMeasure_type = new type_declaration("IfcTorqueMeasure", new simple_type(simple_type::real_type)); - declaration* IfcVaporPermeabilityMeasure_type = new type_declaration("IfcVaporPermeabilityMeasure", new simple_type(simple_type::real_type)); - declaration* IfcVolumeMeasure_type = new type_declaration("IfcVolumeMeasure", new simple_type(simple_type::real_type)); - declaration* IfcVolumetricFlowRateMeasure_type = new type_declaration("IfcVolumetricFlowRateMeasure", new simple_type(simple_type::real_type)); - declaration* IfcWarpingConstantMeasure_type = new type_declaration("IfcWarpingConstantMeasure", new simple_type(simple_type::real_type)); - declaration* IfcWarpingMomentMeasure_type = new type_declaration("IfcWarpingMomentMeasure", new simple_type(simple_type::real_type)); - declaration* IfcYearNumber_type = new type_declaration("IfcYearNumber", new simple_type(simple_type::integer_type)); - declaration* IfcBoxAlignment_type = new type_declaration("IfcBoxAlignment", new named_type(IfcLabel_type)); - declaration* IfcNormalisedRatioMeasure_type = new type_declaration("IfcNormalisedRatioMeasure", new named_type(IfcRatioMeasure_type)); - declaration* IfcPositiveRatioMeasure_type = new type_declaration("IfcPositiveRatioMeasure", new named_type(IfcRatioMeasure_type)); - declaration* IfcActionSourceTypeEnum_type; +using namespace IfcParse; +entity* Ifc2DCompositeCurve_type = 0; +entity* IfcActionRequest_type = 0; +entity* IfcActor_type = 0; +entity* IfcActorRole_type = 0; +entity* IfcActuatorType_type = 0; +entity* IfcAddress_type = 0; +entity* IfcAirTerminalBoxType_type = 0; +entity* IfcAirTerminalType_type = 0; +entity* IfcAirToAirHeatRecoveryType_type = 0; +entity* IfcAlarmType_type = 0; +entity* IfcAngularDimension_type = 0; +entity* IfcAnnotation_type = 0; +entity* IfcAnnotationCurveOccurrence_type = 0; +entity* IfcAnnotationFillArea_type = 0; +entity* IfcAnnotationFillAreaOccurrence_type = 0; +entity* IfcAnnotationOccurrence_type = 0; +entity* IfcAnnotationSurface_type = 0; +entity* IfcAnnotationSurfaceOccurrence_type = 0; +entity* IfcAnnotationSymbolOccurrence_type = 0; +entity* IfcAnnotationTextOccurrence_type = 0; +entity* IfcApplication_type = 0; +entity* IfcAppliedValue_type = 0; +entity* IfcAppliedValueRelationship_type = 0; +entity* IfcApproval_type = 0; +entity* IfcApprovalActorRelationship_type = 0; +entity* IfcApprovalPropertyRelationship_type = 0; +entity* IfcApprovalRelationship_type = 0; +entity* IfcArbitraryClosedProfileDef_type = 0; +entity* IfcArbitraryOpenProfileDef_type = 0; +entity* IfcArbitraryProfileDefWithVoids_type = 0; +entity* IfcAsset_type = 0; +entity* IfcAsymmetricIShapeProfileDef_type = 0; +entity* IfcAxis1Placement_type = 0; +entity* IfcAxis2Placement2D_type = 0; +entity* IfcAxis2Placement3D_type = 0; +entity* IfcBSplineCurve_type = 0; +entity* IfcBeam_type = 0; +entity* IfcBeamType_type = 0; +entity* IfcBezierCurve_type = 0; +entity* IfcBlobTexture_type = 0; +entity* IfcBlock_type = 0; +entity* IfcBoilerType_type = 0; +entity* IfcBooleanClippingResult_type = 0; +entity* IfcBooleanResult_type = 0; +entity* IfcBoundaryCondition_type = 0; +entity* IfcBoundaryEdgeCondition_type = 0; +entity* IfcBoundaryFaceCondition_type = 0; +entity* IfcBoundaryNodeCondition_type = 0; +entity* IfcBoundaryNodeConditionWarping_type = 0; +entity* IfcBoundedCurve_type = 0; +entity* IfcBoundedSurface_type = 0; +entity* IfcBoundingBox_type = 0; +entity* IfcBoxedHalfSpace_type = 0; +entity* IfcBuilding_type = 0; +entity* IfcBuildingElement_type = 0; +entity* IfcBuildingElementComponent_type = 0; +entity* IfcBuildingElementPart_type = 0; +entity* IfcBuildingElementProxy_type = 0; +entity* IfcBuildingElementProxyType_type = 0; +entity* IfcBuildingElementType_type = 0; +entity* IfcBuildingStorey_type = 0; +entity* IfcCShapeProfileDef_type = 0; +entity* IfcCableCarrierFittingType_type = 0; +entity* IfcCableCarrierSegmentType_type = 0; +entity* IfcCableSegmentType_type = 0; +entity* IfcCalendarDate_type = 0; +entity* IfcCartesianPoint_type = 0; +entity* IfcCartesianTransformationOperator_type = 0; +entity* IfcCartesianTransformationOperator2D_type = 0; +entity* IfcCartesianTransformationOperator2DnonUniform_type = 0; +entity* IfcCartesianTransformationOperator3D_type = 0; +entity* IfcCartesianTransformationOperator3DnonUniform_type = 0; +entity* IfcCenterLineProfileDef_type = 0; +entity* IfcChamferEdgeFeature_type = 0; +entity* IfcChillerType_type = 0; +entity* IfcCircle_type = 0; +entity* IfcCircleHollowProfileDef_type = 0; +entity* IfcCircleProfileDef_type = 0; +entity* IfcClassification_type = 0; +entity* IfcClassificationItem_type = 0; +entity* IfcClassificationItemRelationship_type = 0; +entity* IfcClassificationNotation_type = 0; +entity* IfcClassificationNotationFacet_type = 0; +entity* IfcClassificationReference_type = 0; +entity* IfcClosedShell_type = 0; +entity* IfcCoilType_type = 0; +entity* IfcColourRgb_type = 0; +entity* IfcColourSpecification_type = 0; +entity* IfcColumn_type = 0; +entity* IfcColumnType_type = 0; +entity* IfcComplexProperty_type = 0; +entity* IfcCompositeCurve_type = 0; +entity* IfcCompositeCurveSegment_type = 0; +entity* IfcCompositeProfileDef_type = 0; +entity* IfcCompressorType_type = 0; +entity* IfcCondenserType_type = 0; +entity* IfcCondition_type = 0; +entity* IfcConditionCriterion_type = 0; +entity* IfcConic_type = 0; +entity* IfcConnectedFaceSet_type = 0; +entity* IfcConnectionCurveGeometry_type = 0; +entity* IfcConnectionGeometry_type = 0; +entity* IfcConnectionPointEccentricity_type = 0; +entity* IfcConnectionPointGeometry_type = 0; +entity* IfcConnectionPortGeometry_type = 0; +entity* IfcConnectionSurfaceGeometry_type = 0; +entity* IfcConstraint_type = 0; +entity* IfcConstraintAggregationRelationship_type = 0; +entity* IfcConstraintClassificationRelationship_type = 0; +entity* IfcConstraintRelationship_type = 0; +entity* IfcConstructionEquipmentResource_type = 0; +entity* IfcConstructionMaterialResource_type = 0; +entity* IfcConstructionProductResource_type = 0; +entity* IfcConstructionResource_type = 0; +entity* IfcContextDependentUnit_type = 0; +entity* IfcControl_type = 0; +entity* IfcControllerType_type = 0; +entity* IfcConversionBasedUnit_type = 0; +entity* IfcCooledBeamType_type = 0; +entity* IfcCoolingTowerType_type = 0; +entity* IfcCoordinatedUniversalTimeOffset_type = 0; +entity* IfcCostItem_type = 0; +entity* IfcCostSchedule_type = 0; +entity* IfcCostValue_type = 0; +entity* IfcCovering_type = 0; +entity* IfcCoveringType_type = 0; +entity* IfcCraneRailAShapeProfileDef_type = 0; +entity* IfcCraneRailFShapeProfileDef_type = 0; +entity* IfcCrewResource_type = 0; +entity* IfcCsgPrimitive3D_type = 0; +entity* IfcCsgSolid_type = 0; +entity* IfcCurrencyRelationship_type = 0; +entity* IfcCurtainWall_type = 0; +entity* IfcCurtainWallType_type = 0; +entity* IfcCurve_type = 0; +entity* IfcCurveBoundedPlane_type = 0; +entity* IfcCurveStyle_type = 0; +entity* IfcCurveStyleFont_type = 0; +entity* IfcCurveStyleFontAndScaling_type = 0; +entity* IfcCurveStyleFontPattern_type = 0; +entity* IfcDamperType_type = 0; +entity* IfcDateAndTime_type = 0; +entity* IfcDefinedSymbol_type = 0; +entity* IfcDerivedProfileDef_type = 0; +entity* IfcDerivedUnit_type = 0; +entity* IfcDerivedUnitElement_type = 0; +entity* IfcDiameterDimension_type = 0; +entity* IfcDimensionCalloutRelationship_type = 0; +entity* IfcDimensionCurve_type = 0; +entity* IfcDimensionCurveDirectedCallout_type = 0; +entity* IfcDimensionCurveTerminator_type = 0; +entity* IfcDimensionPair_type = 0; +entity* IfcDimensionalExponents_type = 0; +entity* IfcDirection_type = 0; +entity* IfcDiscreteAccessory_type = 0; +entity* IfcDiscreteAccessoryType_type = 0; +entity* IfcDistributionChamberElement_type = 0; +entity* IfcDistributionChamberElementType_type = 0; +entity* IfcDistributionControlElement_type = 0; +entity* IfcDistributionControlElementType_type = 0; +entity* IfcDistributionElement_type = 0; +entity* IfcDistributionElementType_type = 0; +entity* IfcDistributionFlowElement_type = 0; +entity* IfcDistributionFlowElementType_type = 0; +entity* IfcDistributionPort_type = 0; +entity* IfcDocumentElectronicFormat_type = 0; +entity* IfcDocumentInformation_type = 0; +entity* IfcDocumentInformationRelationship_type = 0; +entity* IfcDocumentReference_type = 0; +entity* IfcDoor_type = 0; +entity* IfcDoorLiningProperties_type = 0; +entity* IfcDoorPanelProperties_type = 0; +entity* IfcDoorStyle_type = 0; +entity* IfcDraughtingCallout_type = 0; +entity* IfcDraughtingCalloutRelationship_type = 0; +entity* IfcDraughtingPreDefinedColour_type = 0; +entity* IfcDraughtingPreDefinedCurveFont_type = 0; +entity* IfcDraughtingPreDefinedTextFont_type = 0; +entity* IfcDuctFittingType_type = 0; +entity* IfcDuctSegmentType_type = 0; +entity* IfcDuctSilencerType_type = 0; +entity* IfcEdge_type = 0; +entity* IfcEdgeCurve_type = 0; +entity* IfcEdgeFeature_type = 0; +entity* IfcEdgeLoop_type = 0; +entity* IfcElectricApplianceType_type = 0; +entity* IfcElectricDistributionPoint_type = 0; +entity* IfcElectricFlowStorageDeviceType_type = 0; +entity* IfcElectricGeneratorType_type = 0; +entity* IfcElectricHeaterType_type = 0; +entity* IfcElectricMotorType_type = 0; +entity* IfcElectricTimeControlType_type = 0; +entity* IfcElectricalBaseProperties_type = 0; +entity* IfcElectricalCircuit_type = 0; +entity* IfcElectricalElement_type = 0; +entity* IfcElement_type = 0; +entity* IfcElementAssembly_type = 0; +entity* IfcElementComponent_type = 0; +entity* IfcElementComponentType_type = 0; +entity* IfcElementQuantity_type = 0; +entity* IfcElementType_type = 0; +entity* IfcElementarySurface_type = 0; +entity* IfcEllipse_type = 0; +entity* IfcEllipseProfileDef_type = 0; +entity* IfcEnergyConversionDevice_type = 0; +entity* IfcEnergyConversionDeviceType_type = 0; +entity* IfcEnergyProperties_type = 0; +entity* IfcEnvironmentalImpactValue_type = 0; +entity* IfcEquipmentElement_type = 0; +entity* IfcEquipmentStandard_type = 0; +entity* IfcEvaporativeCoolerType_type = 0; +entity* IfcEvaporatorType_type = 0; +entity* IfcExtendedMaterialProperties_type = 0; +entity* IfcExternalReference_type = 0; +entity* IfcExternallyDefinedHatchStyle_type = 0; +entity* IfcExternallyDefinedSurfaceStyle_type = 0; +entity* IfcExternallyDefinedSymbol_type = 0; +entity* IfcExternallyDefinedTextFont_type = 0; +entity* IfcExtrudedAreaSolid_type = 0; +entity* IfcFace_type = 0; +entity* IfcFaceBasedSurfaceModel_type = 0; +entity* IfcFaceBound_type = 0; +entity* IfcFaceOuterBound_type = 0; +entity* IfcFaceSurface_type = 0; +entity* IfcFacetedBrep_type = 0; +entity* IfcFacetedBrepWithVoids_type = 0; +entity* IfcFailureConnectionCondition_type = 0; +entity* IfcFanType_type = 0; +entity* IfcFastener_type = 0; +entity* IfcFastenerType_type = 0; +entity* IfcFeatureElement_type = 0; +entity* IfcFeatureElementAddition_type = 0; +entity* IfcFeatureElementSubtraction_type = 0; +entity* IfcFillAreaStyle_type = 0; +entity* IfcFillAreaStyleHatching_type = 0; +entity* IfcFillAreaStyleTileSymbolWithStyle_type = 0; +entity* IfcFillAreaStyleTiles_type = 0; +entity* IfcFilterType_type = 0; +entity* IfcFireSuppressionTerminalType_type = 0; +entity* IfcFlowController_type = 0; +entity* IfcFlowControllerType_type = 0; +entity* IfcFlowFitting_type = 0; +entity* IfcFlowFittingType_type = 0; +entity* IfcFlowInstrumentType_type = 0; +entity* IfcFlowMeterType_type = 0; +entity* IfcFlowMovingDevice_type = 0; +entity* IfcFlowMovingDeviceType_type = 0; +entity* IfcFlowSegment_type = 0; +entity* IfcFlowSegmentType_type = 0; +entity* IfcFlowStorageDevice_type = 0; +entity* IfcFlowStorageDeviceType_type = 0; +entity* IfcFlowTerminal_type = 0; +entity* IfcFlowTerminalType_type = 0; +entity* IfcFlowTreatmentDevice_type = 0; +entity* IfcFlowTreatmentDeviceType_type = 0; +entity* IfcFluidFlowProperties_type = 0; +entity* IfcFooting_type = 0; +entity* IfcFuelProperties_type = 0; +entity* IfcFurnishingElement_type = 0; +entity* IfcFurnishingElementType_type = 0; +entity* IfcFurnitureStandard_type = 0; +entity* IfcFurnitureType_type = 0; +entity* IfcGasTerminalType_type = 0; +entity* IfcGeneralMaterialProperties_type = 0; +entity* IfcGeneralProfileProperties_type = 0; +entity* IfcGeometricCurveSet_type = 0; +entity* IfcGeometricRepresentationContext_type = 0; +entity* IfcGeometricRepresentationItem_type = 0; +entity* IfcGeometricRepresentationSubContext_type = 0; +entity* IfcGeometricSet_type = 0; +entity* IfcGrid_type = 0; +entity* IfcGridAxis_type = 0; +entity* IfcGridPlacement_type = 0; +entity* IfcGroup_type = 0; +entity* IfcHalfSpaceSolid_type = 0; +entity* IfcHeatExchangerType_type = 0; +entity* IfcHumidifierType_type = 0; +entity* IfcHygroscopicMaterialProperties_type = 0; +entity* IfcIShapeProfileDef_type = 0; +entity* IfcImageTexture_type = 0; +entity* IfcInventory_type = 0; +entity* IfcIrregularTimeSeries_type = 0; +entity* IfcIrregularTimeSeriesValue_type = 0; +entity* IfcJunctionBoxType_type = 0; +entity* IfcLShapeProfileDef_type = 0; +entity* IfcLaborResource_type = 0; +entity* IfcLampType_type = 0; +entity* IfcLibraryInformation_type = 0; +entity* IfcLibraryReference_type = 0; +entity* IfcLightDistributionData_type = 0; +entity* IfcLightFixtureType_type = 0; +entity* IfcLightIntensityDistribution_type = 0; +entity* IfcLightSource_type = 0; +entity* IfcLightSourceAmbient_type = 0; +entity* IfcLightSourceDirectional_type = 0; +entity* IfcLightSourceGoniometric_type = 0; +entity* IfcLightSourcePositional_type = 0; +entity* IfcLightSourceSpot_type = 0; +entity* IfcLine_type = 0; +entity* IfcLinearDimension_type = 0; +entity* IfcLocalPlacement_type = 0; +entity* IfcLocalTime_type = 0; +entity* IfcLoop_type = 0; +entity* IfcManifoldSolidBrep_type = 0; +entity* IfcMappedItem_type = 0; +entity* IfcMaterial_type = 0; +entity* IfcMaterialClassificationRelationship_type = 0; +entity* IfcMaterialDefinitionRepresentation_type = 0; +entity* IfcMaterialLayer_type = 0; +entity* IfcMaterialLayerSet_type = 0; +entity* IfcMaterialLayerSetUsage_type = 0; +entity* IfcMaterialList_type = 0; +entity* IfcMaterialProperties_type = 0; +entity* IfcMeasureWithUnit_type = 0; +entity* IfcMechanicalConcreteMaterialProperties_type = 0; +entity* IfcMechanicalFastener_type = 0; +entity* IfcMechanicalFastenerType_type = 0; +entity* IfcMechanicalMaterialProperties_type = 0; +entity* IfcMechanicalSteelMaterialProperties_type = 0; +entity* IfcMember_type = 0; +entity* IfcMemberType_type = 0; +entity* IfcMetric_type = 0; +entity* IfcMonetaryUnit_type = 0; +entity* IfcMotorConnectionType_type = 0; +entity* IfcMove_type = 0; +entity* IfcNamedUnit_type = 0; +entity* IfcObject_type = 0; +entity* IfcObjectDefinition_type = 0; +entity* IfcObjectPlacement_type = 0; +entity* IfcObjective_type = 0; +entity* IfcOccupant_type = 0; +entity* IfcOffsetCurve2D_type = 0; +entity* IfcOffsetCurve3D_type = 0; +entity* IfcOneDirectionRepeatFactor_type = 0; +entity* IfcOpenShell_type = 0; +entity* IfcOpeningElement_type = 0; +entity* IfcOpticalMaterialProperties_type = 0; +entity* IfcOrderAction_type = 0; +entity* IfcOrganization_type = 0; +entity* IfcOrganizationRelationship_type = 0; +entity* IfcOrientedEdge_type = 0; +entity* IfcOutletType_type = 0; +entity* IfcOwnerHistory_type = 0; +entity* IfcParameterizedProfileDef_type = 0; +entity* IfcPath_type = 0; +entity* IfcPerformanceHistory_type = 0; +entity* IfcPermeableCoveringProperties_type = 0; +entity* IfcPermit_type = 0; +entity* IfcPerson_type = 0; +entity* IfcPersonAndOrganization_type = 0; +entity* IfcPhysicalComplexQuantity_type = 0; +entity* IfcPhysicalQuantity_type = 0; +entity* IfcPhysicalSimpleQuantity_type = 0; +entity* IfcPile_type = 0; +entity* IfcPipeFittingType_type = 0; +entity* IfcPipeSegmentType_type = 0; +entity* IfcPixelTexture_type = 0; +entity* IfcPlacement_type = 0; +entity* IfcPlanarBox_type = 0; +entity* IfcPlanarExtent_type = 0; +entity* IfcPlane_type = 0; +entity* IfcPlate_type = 0; +entity* IfcPlateType_type = 0; +entity* IfcPoint_type = 0; +entity* IfcPointOnCurve_type = 0; +entity* IfcPointOnSurface_type = 0; +entity* IfcPolyLoop_type = 0; +entity* IfcPolygonalBoundedHalfSpace_type = 0; +entity* IfcPolyline_type = 0; +entity* IfcPort_type = 0; +entity* IfcPostalAddress_type = 0; +entity* IfcPreDefinedColour_type = 0; +entity* IfcPreDefinedCurveFont_type = 0; +entity* IfcPreDefinedDimensionSymbol_type = 0; +entity* IfcPreDefinedItem_type = 0; +entity* IfcPreDefinedPointMarkerSymbol_type = 0; +entity* IfcPreDefinedSymbol_type = 0; +entity* IfcPreDefinedTerminatorSymbol_type = 0; +entity* IfcPreDefinedTextFont_type = 0; +entity* IfcPresentationLayerAssignment_type = 0; +entity* IfcPresentationLayerWithStyle_type = 0; +entity* IfcPresentationStyle_type = 0; +entity* IfcPresentationStyleAssignment_type = 0; +entity* IfcProcedure_type = 0; +entity* IfcProcess_type = 0; +entity* IfcProduct_type = 0; +entity* IfcProductDefinitionShape_type = 0; +entity* IfcProductRepresentation_type = 0; +entity* IfcProductsOfCombustionProperties_type = 0; +entity* IfcProfileDef_type = 0; +entity* IfcProfileProperties_type = 0; +entity* IfcProject_type = 0; +entity* IfcProjectOrder_type = 0; +entity* IfcProjectOrderRecord_type = 0; +entity* IfcProjectionCurve_type = 0; +entity* IfcProjectionElement_type = 0; +entity* IfcProperty_type = 0; +entity* IfcPropertyBoundedValue_type = 0; +entity* IfcPropertyConstraintRelationship_type = 0; +entity* IfcPropertyDefinition_type = 0; +entity* IfcPropertyDependencyRelationship_type = 0; +entity* IfcPropertyEnumeratedValue_type = 0; +entity* IfcPropertyEnumeration_type = 0; +entity* IfcPropertyListValue_type = 0; +entity* IfcPropertyReferenceValue_type = 0; +entity* IfcPropertySet_type = 0; +entity* IfcPropertySetDefinition_type = 0; +entity* IfcPropertySingleValue_type = 0; +entity* IfcPropertyTableValue_type = 0; +entity* IfcProtectiveDeviceType_type = 0; +entity* IfcProxy_type = 0; +entity* IfcPumpType_type = 0; +entity* IfcQuantityArea_type = 0; +entity* IfcQuantityCount_type = 0; +entity* IfcQuantityLength_type = 0; +entity* IfcQuantityTime_type = 0; +entity* IfcQuantityVolume_type = 0; +entity* IfcQuantityWeight_type = 0; +entity* IfcRadiusDimension_type = 0; +entity* IfcRailing_type = 0; +entity* IfcRailingType_type = 0; +entity* IfcRamp_type = 0; +entity* IfcRampFlight_type = 0; +entity* IfcRampFlightType_type = 0; +entity* IfcRationalBezierCurve_type = 0; +entity* IfcRectangleHollowProfileDef_type = 0; +entity* IfcRectangleProfileDef_type = 0; +entity* IfcRectangularPyramid_type = 0; +entity* IfcRectangularTrimmedSurface_type = 0; +entity* IfcReferencesValueDocument_type = 0; +entity* IfcRegularTimeSeries_type = 0; +entity* IfcReinforcementBarProperties_type = 0; +entity* IfcReinforcementDefinitionProperties_type = 0; +entity* IfcReinforcingBar_type = 0; +entity* IfcReinforcingElement_type = 0; +entity* IfcReinforcingMesh_type = 0; +entity* IfcRelAggregates_type = 0; +entity* IfcRelAssigns_type = 0; +entity* IfcRelAssignsTasks_type = 0; +entity* IfcRelAssignsToActor_type = 0; +entity* IfcRelAssignsToControl_type = 0; +entity* IfcRelAssignsToGroup_type = 0; +entity* IfcRelAssignsToProcess_type = 0; +entity* IfcRelAssignsToProduct_type = 0; +entity* IfcRelAssignsToProjectOrder_type = 0; +entity* IfcRelAssignsToResource_type = 0; +entity* IfcRelAssociates_type = 0; +entity* IfcRelAssociatesAppliedValue_type = 0; +entity* IfcRelAssociatesApproval_type = 0; +entity* IfcRelAssociatesClassification_type = 0; +entity* IfcRelAssociatesConstraint_type = 0; +entity* IfcRelAssociatesDocument_type = 0; +entity* IfcRelAssociatesLibrary_type = 0; +entity* IfcRelAssociatesMaterial_type = 0; +entity* IfcRelAssociatesProfileProperties_type = 0; +entity* IfcRelConnects_type = 0; +entity* IfcRelConnectsElements_type = 0; +entity* IfcRelConnectsPathElements_type = 0; +entity* IfcRelConnectsPortToElement_type = 0; +entity* IfcRelConnectsPorts_type = 0; +entity* IfcRelConnectsStructuralActivity_type = 0; +entity* IfcRelConnectsStructuralElement_type = 0; +entity* IfcRelConnectsStructuralMember_type = 0; +entity* IfcRelConnectsWithEccentricity_type = 0; +entity* IfcRelConnectsWithRealizingElements_type = 0; +entity* IfcRelContainedInSpatialStructure_type = 0; +entity* IfcRelCoversBldgElements_type = 0; +entity* IfcRelCoversSpaces_type = 0; +entity* IfcRelDecomposes_type = 0; +entity* IfcRelDefines_type = 0; +entity* IfcRelDefinesByProperties_type = 0; +entity* IfcRelDefinesByType_type = 0; +entity* IfcRelFillsElement_type = 0; +entity* IfcRelFlowControlElements_type = 0; +entity* IfcRelInteractionRequirements_type = 0; +entity* IfcRelNests_type = 0; +entity* IfcRelOccupiesSpaces_type = 0; +entity* IfcRelOverridesProperties_type = 0; +entity* IfcRelProjectsElement_type = 0; +entity* IfcRelReferencedInSpatialStructure_type = 0; +entity* IfcRelSchedulesCostItems_type = 0; +entity* IfcRelSequence_type = 0; +entity* IfcRelServicesBuildings_type = 0; +entity* IfcRelSpaceBoundary_type = 0; +entity* IfcRelVoidsElement_type = 0; +entity* IfcRelationship_type = 0; +entity* IfcRelaxation_type = 0; +entity* IfcRepresentation_type = 0; +entity* IfcRepresentationContext_type = 0; +entity* IfcRepresentationItem_type = 0; +entity* IfcRepresentationMap_type = 0; +entity* IfcResource_type = 0; +entity* IfcRevolvedAreaSolid_type = 0; +entity* IfcRibPlateProfileProperties_type = 0; +entity* IfcRightCircularCone_type = 0; +entity* IfcRightCircularCylinder_type = 0; +entity* IfcRoof_type = 0; +entity* IfcRoot_type = 0; +entity* IfcRoundedEdgeFeature_type = 0; +entity* IfcRoundedRectangleProfileDef_type = 0; +entity* IfcSIUnit_type = 0; +entity* IfcSanitaryTerminalType_type = 0; +entity* IfcScheduleTimeControl_type = 0; +entity* IfcSectionProperties_type = 0; +entity* IfcSectionReinforcementProperties_type = 0; +entity* IfcSectionedSpine_type = 0; +entity* IfcSensorType_type = 0; +entity* IfcServiceLife_type = 0; +entity* IfcServiceLifeFactor_type = 0; +entity* IfcShapeAspect_type = 0; +entity* IfcShapeModel_type = 0; +entity* IfcShapeRepresentation_type = 0; +entity* IfcShellBasedSurfaceModel_type = 0; +entity* IfcSimpleProperty_type = 0; +entity* IfcSite_type = 0; +entity* IfcSlab_type = 0; +entity* IfcSlabType_type = 0; +entity* IfcSlippageConnectionCondition_type = 0; +entity* IfcSolidModel_type = 0; +entity* IfcSoundProperties_type = 0; +entity* IfcSoundValue_type = 0; +entity* IfcSpace_type = 0; +entity* IfcSpaceHeaterType_type = 0; +entity* IfcSpaceProgram_type = 0; +entity* IfcSpaceThermalLoadProperties_type = 0; +entity* IfcSpaceType_type = 0; +entity* IfcSpatialStructureElement_type = 0; +entity* IfcSpatialStructureElementType_type = 0; +entity* IfcSphere_type = 0; +entity* IfcStackTerminalType_type = 0; +entity* IfcStair_type = 0; +entity* IfcStairFlight_type = 0; +entity* IfcStairFlightType_type = 0; +entity* IfcStructuralAction_type = 0; +entity* IfcStructuralActivity_type = 0; +entity* IfcStructuralAnalysisModel_type = 0; +entity* IfcStructuralConnection_type = 0; +entity* IfcStructuralConnectionCondition_type = 0; +entity* IfcStructuralCurveConnection_type = 0; +entity* IfcStructuralCurveMember_type = 0; +entity* IfcStructuralCurveMemberVarying_type = 0; +entity* IfcStructuralItem_type = 0; +entity* IfcStructuralLinearAction_type = 0; +entity* IfcStructuralLinearActionVarying_type = 0; +entity* IfcStructuralLoad_type = 0; +entity* IfcStructuralLoadGroup_type = 0; +entity* IfcStructuralLoadLinearForce_type = 0; +entity* IfcStructuralLoadPlanarForce_type = 0; +entity* IfcStructuralLoadSingleDisplacement_type = 0; +entity* IfcStructuralLoadSingleDisplacementDistortion_type = 0; +entity* IfcStructuralLoadSingleForce_type = 0; +entity* IfcStructuralLoadSingleForceWarping_type = 0; +entity* IfcStructuralLoadStatic_type = 0; +entity* IfcStructuralLoadTemperature_type = 0; +entity* IfcStructuralMember_type = 0; +entity* IfcStructuralPlanarAction_type = 0; +entity* IfcStructuralPlanarActionVarying_type = 0; +entity* IfcStructuralPointAction_type = 0; +entity* IfcStructuralPointConnection_type = 0; +entity* IfcStructuralPointReaction_type = 0; +entity* IfcStructuralProfileProperties_type = 0; +entity* IfcStructuralReaction_type = 0; +entity* IfcStructuralResultGroup_type = 0; +entity* IfcStructuralSteelProfileProperties_type = 0; +entity* IfcStructuralSurfaceConnection_type = 0; +entity* IfcStructuralSurfaceMember_type = 0; +entity* IfcStructuralSurfaceMemberVarying_type = 0; +entity* IfcStructuredDimensionCallout_type = 0; +entity* IfcStyleModel_type = 0; +entity* IfcStyledItem_type = 0; +entity* IfcStyledRepresentation_type = 0; +entity* IfcSubContractResource_type = 0; +entity* IfcSubedge_type = 0; +entity* IfcSurface_type = 0; +entity* IfcSurfaceCurveSweptAreaSolid_type = 0; +entity* IfcSurfaceOfLinearExtrusion_type = 0; +entity* IfcSurfaceOfRevolution_type = 0; +entity* IfcSurfaceStyle_type = 0; +entity* IfcSurfaceStyleLighting_type = 0; +entity* IfcSurfaceStyleRefraction_type = 0; +entity* IfcSurfaceStyleRendering_type = 0; +entity* IfcSurfaceStyleShading_type = 0; +entity* IfcSurfaceStyleWithTextures_type = 0; +entity* IfcSurfaceTexture_type = 0; +entity* IfcSweptAreaSolid_type = 0; +entity* IfcSweptDiskSolid_type = 0; +entity* IfcSweptSurface_type = 0; +entity* IfcSwitchingDeviceType_type = 0; +entity* IfcSymbolStyle_type = 0; +entity* IfcSystem_type = 0; +entity* IfcSystemFurnitureElementType_type = 0; +entity* IfcTShapeProfileDef_type = 0; +entity* IfcTable_type = 0; +entity* IfcTableRow_type = 0; +entity* IfcTankType_type = 0; +entity* IfcTask_type = 0; +entity* IfcTelecomAddress_type = 0; +entity* IfcTendon_type = 0; +entity* IfcTendonAnchor_type = 0; +entity* IfcTerminatorSymbol_type = 0; +entity* IfcTextLiteral_type = 0; +entity* IfcTextLiteralWithExtent_type = 0; +entity* IfcTextStyle_type = 0; +entity* IfcTextStyleFontModel_type = 0; +entity* IfcTextStyleForDefinedFont_type = 0; +entity* IfcTextStyleTextModel_type = 0; +entity* IfcTextStyleWithBoxCharacteristics_type = 0; +entity* IfcTextureCoordinate_type = 0; +entity* IfcTextureCoordinateGenerator_type = 0; +entity* IfcTextureMap_type = 0; +entity* IfcTextureVertex_type = 0; +entity* IfcThermalMaterialProperties_type = 0; +entity* IfcTimeSeries_type = 0; +entity* IfcTimeSeriesReferenceRelationship_type = 0; +entity* IfcTimeSeriesSchedule_type = 0; +entity* IfcTimeSeriesValue_type = 0; +entity* IfcTopologicalRepresentationItem_type = 0; +entity* IfcTopologyRepresentation_type = 0; +entity* IfcTransformerType_type = 0; +entity* IfcTransportElement_type = 0; +entity* IfcTransportElementType_type = 0; +entity* IfcTrapeziumProfileDef_type = 0; +entity* IfcTrimmedCurve_type = 0; +entity* IfcTubeBundleType_type = 0; +entity* IfcTwoDirectionRepeatFactor_type = 0; +entity* IfcTypeObject_type = 0; +entity* IfcTypeProduct_type = 0; +entity* IfcUShapeProfileDef_type = 0; +entity* IfcUnitAssignment_type = 0; +entity* IfcUnitaryEquipmentType_type = 0; +entity* IfcValveType_type = 0; +entity* IfcVector_type = 0; +entity* IfcVertex_type = 0; +entity* IfcVertexBasedTextureMap_type = 0; +entity* IfcVertexLoop_type = 0; +entity* IfcVertexPoint_type = 0; +entity* IfcVibrationIsolatorType_type = 0; +entity* IfcVirtualElement_type = 0; +entity* IfcVirtualGridIntersection_type = 0; +entity* IfcWall_type = 0; +entity* IfcWallStandardCase_type = 0; +entity* IfcWallType_type = 0; +entity* IfcWasteTerminalType_type = 0; +entity* IfcWaterProperties_type = 0; +entity* IfcWindow_type = 0; +entity* IfcWindowLiningProperties_type = 0; +entity* IfcWindowPanelProperties_type = 0; +entity* IfcWindowStyle_type = 0; +entity* IfcWorkControl_type = 0; +entity* IfcWorkPlan_type = 0; +entity* IfcWorkSchedule_type = 0; +entity* IfcZShapeProfileDef_type = 0; +entity* IfcZone_type = 0; +type_declaration* IfcAbsorbedDoseMeasure_type = 0; +type_declaration* IfcAccelerationMeasure_type = 0; +type_declaration* IfcAmountOfSubstanceMeasure_type = 0; +type_declaration* IfcAngularVelocityMeasure_type = 0; +type_declaration* IfcAreaMeasure_type = 0; +type_declaration* IfcBoolean_type = 0; +type_declaration* IfcBoxAlignment_type = 0; +type_declaration* IfcComplexNumber_type = 0; +type_declaration* IfcCompoundPlaneAngleMeasure_type = 0; +type_declaration* IfcContextDependentMeasure_type = 0; +type_declaration* IfcCountMeasure_type = 0; +type_declaration* IfcCurvatureMeasure_type = 0; +type_declaration* IfcDayInMonthNumber_type = 0; +type_declaration* IfcDaylightSavingHour_type = 0; +type_declaration* IfcDescriptiveMeasure_type = 0; +type_declaration* IfcDimensionCount_type = 0; +type_declaration* IfcDoseEquivalentMeasure_type = 0; +type_declaration* IfcDynamicViscosityMeasure_type = 0; +type_declaration* IfcElectricCapacitanceMeasure_type = 0; +type_declaration* IfcElectricChargeMeasure_type = 0; +type_declaration* IfcElectricConductanceMeasure_type = 0; +type_declaration* IfcElectricCurrentMeasure_type = 0; +type_declaration* IfcElectricResistanceMeasure_type = 0; +type_declaration* IfcElectricVoltageMeasure_type = 0; +type_declaration* IfcEnergyMeasure_type = 0; +type_declaration* IfcFontStyle_type = 0; +type_declaration* IfcFontVariant_type = 0; +type_declaration* IfcFontWeight_type = 0; +type_declaration* IfcForceMeasure_type = 0; +type_declaration* IfcFrequencyMeasure_type = 0; +type_declaration* IfcGloballyUniqueId_type = 0; +type_declaration* IfcHeatFluxDensityMeasure_type = 0; +type_declaration* IfcHeatingValueMeasure_type = 0; +type_declaration* IfcHourInDay_type = 0; +type_declaration* IfcIdentifier_type = 0; +type_declaration* IfcIlluminanceMeasure_type = 0; +type_declaration* IfcInductanceMeasure_type = 0; +type_declaration* IfcInteger_type = 0; +type_declaration* IfcIntegerCountRateMeasure_type = 0; +type_declaration* IfcIonConcentrationMeasure_type = 0; +type_declaration* IfcIsothermalMoistureCapacityMeasure_type = 0; +type_declaration* IfcKinematicViscosityMeasure_type = 0; +type_declaration* IfcLabel_type = 0; +type_declaration* IfcLengthMeasure_type = 0; +type_declaration* IfcLinearForceMeasure_type = 0; +type_declaration* IfcLinearMomentMeasure_type = 0; +type_declaration* IfcLinearStiffnessMeasure_type = 0; +type_declaration* IfcLinearVelocityMeasure_type = 0; +type_declaration* IfcLogical_type = 0; +type_declaration* IfcLuminousFluxMeasure_type = 0; +type_declaration* IfcLuminousIntensityDistributionMeasure_type = 0; +type_declaration* IfcLuminousIntensityMeasure_type = 0; +type_declaration* IfcMagneticFluxDensityMeasure_type = 0; +type_declaration* IfcMagneticFluxMeasure_type = 0; +type_declaration* IfcMassDensityMeasure_type = 0; +type_declaration* IfcMassFlowRateMeasure_type = 0; +type_declaration* IfcMassMeasure_type = 0; +type_declaration* IfcMassPerLengthMeasure_type = 0; +type_declaration* IfcMinuteInHour_type = 0; +type_declaration* IfcModulusOfElasticityMeasure_type = 0; +type_declaration* IfcModulusOfLinearSubgradeReactionMeasure_type = 0; +type_declaration* IfcModulusOfRotationalSubgradeReactionMeasure_type = 0; +type_declaration* IfcModulusOfSubgradeReactionMeasure_type = 0; +type_declaration* IfcMoistureDiffusivityMeasure_type = 0; +type_declaration* IfcMolecularWeightMeasure_type = 0; +type_declaration* IfcMomentOfInertiaMeasure_type = 0; +type_declaration* IfcMonetaryMeasure_type = 0; +type_declaration* IfcMonthInYearNumber_type = 0; +type_declaration* IfcNormalisedRatioMeasure_type = 0; +type_declaration* IfcNumericMeasure_type = 0; +type_declaration* IfcPHMeasure_type = 0; +type_declaration* IfcParameterValue_type = 0; +type_declaration* IfcPlanarForceMeasure_type = 0; +type_declaration* IfcPlaneAngleMeasure_type = 0; +type_declaration* IfcPositiveLengthMeasure_type = 0; +type_declaration* IfcPositivePlaneAngleMeasure_type = 0; +type_declaration* IfcPositiveRatioMeasure_type = 0; +type_declaration* IfcPowerMeasure_type = 0; +type_declaration* IfcPresentableText_type = 0; +type_declaration* IfcPressureMeasure_type = 0; +type_declaration* IfcRadioActivityMeasure_type = 0; +type_declaration* IfcRatioMeasure_type = 0; +type_declaration* IfcReal_type = 0; +type_declaration* IfcRotationalFrequencyMeasure_type = 0; +type_declaration* IfcRotationalMassMeasure_type = 0; +type_declaration* IfcRotationalStiffnessMeasure_type = 0; +type_declaration* IfcSecondInMinute_type = 0; +type_declaration* IfcSectionModulusMeasure_type = 0; +type_declaration* IfcSectionalAreaIntegralMeasure_type = 0; +type_declaration* IfcShearModulusMeasure_type = 0; +type_declaration* IfcSolidAngleMeasure_type = 0; +type_declaration* IfcSoundPowerMeasure_type = 0; +type_declaration* IfcSoundPressureMeasure_type = 0; +type_declaration* IfcSpecificHeatCapacityMeasure_type = 0; +type_declaration* IfcSpecularExponent_type = 0; +type_declaration* IfcSpecularRoughness_type = 0; +type_declaration* IfcTemperatureGradientMeasure_type = 0; +type_declaration* IfcText_type = 0; +type_declaration* IfcTextAlignment_type = 0; +type_declaration* IfcTextDecoration_type = 0; +type_declaration* IfcTextFontName_type = 0; +type_declaration* IfcTextTransformation_type = 0; +type_declaration* IfcThermalAdmittanceMeasure_type = 0; +type_declaration* IfcThermalConductivityMeasure_type = 0; +type_declaration* IfcThermalExpansionCoefficientMeasure_type = 0; +type_declaration* IfcThermalResistanceMeasure_type = 0; +type_declaration* IfcThermalTransmittanceMeasure_type = 0; +type_declaration* IfcThermodynamicTemperatureMeasure_type = 0; +type_declaration* IfcTimeMeasure_type = 0; +type_declaration* IfcTimeStamp_type = 0; +type_declaration* IfcTorqueMeasure_type = 0; +type_declaration* IfcVaporPermeabilityMeasure_type = 0; +type_declaration* IfcVolumeMeasure_type = 0; +type_declaration* IfcVolumetricFlowRateMeasure_type = 0; +type_declaration* IfcWarpingConstantMeasure_type = 0; +type_declaration* IfcWarpingMomentMeasure_type = 0; +type_declaration* IfcYearNumber_type = 0; +select_type* IfcActorSelect_type = 0; +select_type* IfcAppliedValueSelect_type = 0; +select_type* IfcAxis2Placement_type = 0; +select_type* IfcBooleanOperand_type = 0; +select_type* IfcCharacterStyleSelect_type = 0; +select_type* IfcClassificationNotationSelect_type = 0; +select_type* IfcColour_type = 0; +select_type* IfcColourOrFactor_type = 0; +select_type* IfcConditionCriterionSelect_type = 0; +select_type* IfcCsgSelect_type = 0; +select_type* IfcCurveFontOrScaledCurveFontSelect_type = 0; +select_type* IfcCurveOrEdgeCurve_type = 0; +select_type* IfcCurveStyleFontSelect_type = 0; +select_type* IfcDateTimeSelect_type = 0; +select_type* IfcDefinedSymbolSelect_type = 0; +select_type* IfcDerivedMeasureValue_type = 0; +select_type* IfcDocumentSelect_type = 0; +select_type* IfcDraughtingCalloutElement_type = 0; +select_type* IfcFillAreaStyleTileShapeSelect_type = 0; +select_type* IfcFillStyleSelect_type = 0; +select_type* IfcGeometricSetSelect_type = 0; +select_type* IfcHatchLineDistanceSelect_type = 0; +select_type* IfcLayeredItem_type = 0; +select_type* IfcLibrarySelect_type = 0; +select_type* IfcLightDistributionDataSourceSelect_type = 0; +select_type* IfcMaterialSelect_type = 0; +select_type* IfcMeasureValue_type = 0; +select_type* IfcMetricValueSelect_type = 0; +select_type* IfcObjectReferenceSelect_type = 0; +select_type* IfcOrientationSelect_type = 0; +select_type* IfcPointOrVertexPoint_type = 0; +select_type* IfcPresentationStyleSelect_type = 0; +select_type* IfcShell_type = 0; +select_type* IfcSimpleValue_type = 0; +select_type* IfcSizeSelect_type = 0; +select_type* IfcSpecularHighlightSelect_type = 0; +select_type* IfcStructuralActivityAssignmentSelect_type = 0; +select_type* IfcSurfaceOrFaceSurface_type = 0; +select_type* IfcSurfaceStyleElementSelect_type = 0; +select_type* IfcSymbolStyleSelect_type = 0; +select_type* IfcTextFontSelect_type = 0; +select_type* IfcTextStyleSelect_type = 0; +select_type* IfcTrimmingSelect_type = 0; +select_type* IfcUnit_type = 0; +select_type* IfcValue_type = 0; +select_type* IfcVectorOrDirection_type = 0; +enumeration_type* IfcActionSourceTypeEnum_type = 0; +enumeration_type* IfcActionTypeEnum_type = 0; +enumeration_type* IfcActuatorTypeEnum_type = 0; +enumeration_type* IfcAddressTypeEnum_type = 0; +enumeration_type* IfcAheadOrBehind_type = 0; +enumeration_type* IfcAirTerminalBoxTypeEnum_type = 0; +enumeration_type* IfcAirTerminalTypeEnum_type = 0; +enumeration_type* IfcAirToAirHeatRecoveryTypeEnum_type = 0; +enumeration_type* IfcAlarmTypeEnum_type = 0; +enumeration_type* IfcAnalysisModelTypeEnum_type = 0; +enumeration_type* IfcAnalysisTheoryTypeEnum_type = 0; +enumeration_type* IfcArithmeticOperatorEnum_type = 0; +enumeration_type* IfcAssemblyPlaceEnum_type = 0; +enumeration_type* IfcBSplineCurveForm_type = 0; +enumeration_type* IfcBeamTypeEnum_type = 0; +enumeration_type* IfcBenchmarkEnum_type = 0; +enumeration_type* IfcBoilerTypeEnum_type = 0; +enumeration_type* IfcBooleanOperator_type = 0; +enumeration_type* IfcBuildingElementProxyTypeEnum_type = 0; +enumeration_type* IfcCableCarrierFittingTypeEnum_type = 0; +enumeration_type* IfcCableCarrierSegmentTypeEnum_type = 0; +enumeration_type* IfcCableSegmentTypeEnum_type = 0; +enumeration_type* IfcChangeActionEnum_type = 0; +enumeration_type* IfcChillerTypeEnum_type = 0; +enumeration_type* IfcCoilTypeEnum_type = 0; +enumeration_type* IfcColumnTypeEnum_type = 0; +enumeration_type* IfcCompressorTypeEnum_type = 0; +enumeration_type* IfcCondenserTypeEnum_type = 0; +enumeration_type* IfcConnectionTypeEnum_type = 0; +enumeration_type* IfcConstraintEnum_type = 0; +enumeration_type* IfcControllerTypeEnum_type = 0; +enumeration_type* IfcCooledBeamTypeEnum_type = 0; +enumeration_type* IfcCoolingTowerTypeEnum_type = 0; +enumeration_type* IfcCostScheduleTypeEnum_type = 0; +enumeration_type* IfcCoveringTypeEnum_type = 0; +enumeration_type* IfcCurrencyEnum_type = 0; +enumeration_type* IfcCurtainWallTypeEnum_type = 0; +enumeration_type* IfcDamperTypeEnum_type = 0; +enumeration_type* IfcDataOriginEnum_type = 0; +enumeration_type* IfcDerivedUnitEnum_type = 0; +enumeration_type* IfcDimensionExtentUsage_type = 0; +enumeration_type* IfcDirectionSenseEnum_type = 0; +enumeration_type* IfcDistributionChamberElementTypeEnum_type = 0; +enumeration_type* IfcDocumentConfidentialityEnum_type = 0; +enumeration_type* IfcDocumentStatusEnum_type = 0; +enumeration_type* IfcDoorPanelOperationEnum_type = 0; +enumeration_type* IfcDoorPanelPositionEnum_type = 0; +enumeration_type* IfcDoorStyleConstructionEnum_type = 0; +enumeration_type* IfcDoorStyleOperationEnum_type = 0; +enumeration_type* IfcDuctFittingTypeEnum_type = 0; +enumeration_type* IfcDuctSegmentTypeEnum_type = 0; +enumeration_type* IfcDuctSilencerTypeEnum_type = 0; +enumeration_type* IfcElectricApplianceTypeEnum_type = 0; +enumeration_type* IfcElectricCurrentEnum_type = 0; +enumeration_type* IfcElectricDistributionPointFunctionEnum_type = 0; +enumeration_type* IfcElectricFlowStorageDeviceTypeEnum_type = 0; +enumeration_type* IfcElectricGeneratorTypeEnum_type = 0; +enumeration_type* IfcElectricHeaterTypeEnum_type = 0; +enumeration_type* IfcElectricMotorTypeEnum_type = 0; +enumeration_type* IfcElectricTimeControlTypeEnum_type = 0; +enumeration_type* IfcElementAssemblyTypeEnum_type = 0; +enumeration_type* IfcElementCompositionEnum_type = 0; +enumeration_type* IfcEnergySequenceEnum_type = 0; +enumeration_type* IfcEnvironmentalImpactCategoryEnum_type = 0; +enumeration_type* IfcEvaporativeCoolerTypeEnum_type = 0; +enumeration_type* IfcEvaporatorTypeEnum_type = 0; +enumeration_type* IfcFanTypeEnum_type = 0; +enumeration_type* IfcFilterTypeEnum_type = 0; +enumeration_type* IfcFireSuppressionTerminalTypeEnum_type = 0; +enumeration_type* IfcFlowDirectionEnum_type = 0; +enumeration_type* IfcFlowInstrumentTypeEnum_type = 0; +enumeration_type* IfcFlowMeterTypeEnum_type = 0; +enumeration_type* IfcFootingTypeEnum_type = 0; +enumeration_type* IfcGasTerminalTypeEnum_type = 0; +enumeration_type* IfcGeometricProjectionEnum_type = 0; +enumeration_type* IfcGlobalOrLocalEnum_type = 0; +enumeration_type* IfcHeatExchangerTypeEnum_type = 0; +enumeration_type* IfcHumidifierTypeEnum_type = 0; +enumeration_type* IfcInternalOrExternalEnum_type = 0; +enumeration_type* IfcInventoryTypeEnum_type = 0; +enumeration_type* IfcJunctionBoxTypeEnum_type = 0; +enumeration_type* IfcLampTypeEnum_type = 0; +enumeration_type* IfcLayerSetDirectionEnum_type = 0; +enumeration_type* IfcLightDistributionCurveEnum_type = 0; +enumeration_type* IfcLightEmissionSourceEnum_type = 0; +enumeration_type* IfcLightFixtureTypeEnum_type = 0; +enumeration_type* IfcLoadGroupTypeEnum_type = 0; +enumeration_type* IfcLogicalOperatorEnum_type = 0; +enumeration_type* IfcMemberTypeEnum_type = 0; +enumeration_type* IfcMotorConnectionTypeEnum_type = 0; +enumeration_type* IfcNullStyle_type = 0; +enumeration_type* IfcObjectTypeEnum_type = 0; +enumeration_type* IfcObjectiveEnum_type = 0; +enumeration_type* IfcOccupantTypeEnum_type = 0; +enumeration_type* IfcOutletTypeEnum_type = 0; +enumeration_type* IfcPermeableCoveringOperationEnum_type = 0; +enumeration_type* IfcPhysicalOrVirtualEnum_type = 0; +enumeration_type* IfcPileConstructionEnum_type = 0; +enumeration_type* IfcPileTypeEnum_type = 0; +enumeration_type* IfcPipeFittingTypeEnum_type = 0; +enumeration_type* IfcPipeSegmentTypeEnum_type = 0; +enumeration_type* IfcPlateTypeEnum_type = 0; +enumeration_type* IfcProcedureTypeEnum_type = 0; +enumeration_type* IfcProfileTypeEnum_type = 0; +enumeration_type* IfcProjectOrderRecordTypeEnum_type = 0; +enumeration_type* IfcProjectOrderTypeEnum_type = 0; +enumeration_type* IfcProjectedOrTrueLengthEnum_type = 0; +enumeration_type* IfcPropertySourceEnum_type = 0; +enumeration_type* IfcProtectiveDeviceTypeEnum_type = 0; +enumeration_type* IfcPumpTypeEnum_type = 0; +enumeration_type* IfcRailingTypeEnum_type = 0; +enumeration_type* IfcRampFlightTypeEnum_type = 0; +enumeration_type* IfcRampTypeEnum_type = 0; +enumeration_type* IfcReflectanceMethodEnum_type = 0; +enumeration_type* IfcReinforcingBarRoleEnum_type = 0; +enumeration_type* IfcReinforcingBarSurfaceEnum_type = 0; +enumeration_type* IfcResourceConsumptionEnum_type = 0; +enumeration_type* IfcRibPlateDirectionEnum_type = 0; +enumeration_type* IfcRoleEnum_type = 0; +enumeration_type* IfcRoofTypeEnum_type = 0; +enumeration_type* IfcSIPrefix_type = 0; +enumeration_type* IfcSIUnitName_type = 0; +enumeration_type* IfcSanitaryTerminalTypeEnum_type = 0; +enumeration_type* IfcSectionTypeEnum_type = 0; +enumeration_type* IfcSensorTypeEnum_type = 0; +enumeration_type* IfcSequenceEnum_type = 0; +enumeration_type* IfcServiceLifeFactorTypeEnum_type = 0; +enumeration_type* IfcServiceLifeTypeEnum_type = 0; +enumeration_type* IfcSlabTypeEnum_type = 0; +enumeration_type* IfcSoundScaleEnum_type = 0; +enumeration_type* IfcSpaceHeaterTypeEnum_type = 0; +enumeration_type* IfcSpaceTypeEnum_type = 0; +enumeration_type* IfcStackTerminalTypeEnum_type = 0; +enumeration_type* IfcStairFlightTypeEnum_type = 0; +enumeration_type* IfcStairTypeEnum_type = 0; +enumeration_type* IfcStateEnum_type = 0; +enumeration_type* IfcStructuralCurveTypeEnum_type = 0; +enumeration_type* IfcStructuralSurfaceTypeEnum_type = 0; +enumeration_type* IfcSurfaceSide_type = 0; +enumeration_type* IfcSurfaceTextureEnum_type = 0; +enumeration_type* IfcSwitchingDeviceTypeEnum_type = 0; +enumeration_type* IfcTankTypeEnum_type = 0; +enumeration_type* IfcTendonTypeEnum_type = 0; +enumeration_type* IfcTextPath_type = 0; +enumeration_type* IfcThermalLoadSourceEnum_type = 0; +enumeration_type* IfcThermalLoadTypeEnum_type = 0; +enumeration_type* IfcTimeSeriesDataTypeEnum_type = 0; +enumeration_type* IfcTimeSeriesScheduleTypeEnum_type = 0; +enumeration_type* IfcTransformerTypeEnum_type = 0; +enumeration_type* IfcTransitionCode_type = 0; +enumeration_type* IfcTransportElementTypeEnum_type = 0; +enumeration_type* IfcTrimmingPreference_type = 0; +enumeration_type* IfcTubeBundleTypeEnum_type = 0; +enumeration_type* IfcUnitEnum_type = 0; +enumeration_type* IfcUnitaryEquipmentTypeEnum_type = 0; +enumeration_type* IfcValveTypeEnum_type = 0; +enumeration_type* IfcVibrationIsolatorTypeEnum_type = 0; +enumeration_type* IfcWallTypeEnum_type = 0; +enumeration_type* IfcWasteTerminalTypeEnum_type = 0; +enumeration_type* IfcWindowPanelOperationEnum_type = 0; +enumeration_type* IfcWindowPanelPositionEnum_type = 0; +enumeration_type* IfcWindowStyleConstructionEnum_type = 0; +enumeration_type* IfcWindowStyleOperationEnum_type = 0; +enumeration_type* IfcWorkControlTypeEnum_type = 0; +schema_definition* populate_schema() { + IfcAbsorbedDoseMeasure_type = new type_declaration(IfcSchema::Type::IfcAbsorbedDoseMeasure, new simple_type(simple_type::real_type)); + IfcAccelerationMeasure_type = new type_declaration(IfcSchema::Type::IfcAccelerationMeasure, new simple_type(simple_type::real_type)); + IfcAmountOfSubstanceMeasure_type = new type_declaration(IfcSchema::Type::IfcAmountOfSubstanceMeasure, new simple_type(simple_type::real_type)); + IfcAngularVelocityMeasure_type = new type_declaration(IfcSchema::Type::IfcAngularVelocityMeasure, new simple_type(simple_type::real_type)); + IfcAreaMeasure_type = new type_declaration(IfcSchema::Type::IfcAreaMeasure, new simple_type(simple_type::real_type)); + IfcBoolean_type = new type_declaration(IfcSchema::Type::IfcBoolean, new simple_type(simple_type::boolean_type)); + IfcComplexNumber_type = new type_declaration(IfcSchema::Type::IfcComplexNumber, new aggregation_type(aggregation_type::array_type, 1, 2, new simple_type(simple_type::real_type))); + IfcCompoundPlaneAngleMeasure_type = new type_declaration(IfcSchema::Type::IfcCompoundPlaneAngleMeasure, new aggregation_type(aggregation_type::list_type, 3, 4, new simple_type(simple_type::integer_type))); + IfcContextDependentMeasure_type = new type_declaration(IfcSchema::Type::IfcContextDependentMeasure, new simple_type(simple_type::real_type)); + IfcCountMeasure_type = new type_declaration(IfcSchema::Type::IfcCountMeasure, new simple_type(simple_type::number_type)); + IfcCurvatureMeasure_type = new type_declaration(IfcSchema::Type::IfcCurvatureMeasure, new simple_type(simple_type::real_type)); + IfcDayInMonthNumber_type = new type_declaration(IfcSchema::Type::IfcDayInMonthNumber, new simple_type(simple_type::integer_type)); + IfcDaylightSavingHour_type = new type_declaration(IfcSchema::Type::IfcDaylightSavingHour, new simple_type(simple_type::integer_type)); + IfcDescriptiveMeasure_type = new type_declaration(IfcSchema::Type::IfcDescriptiveMeasure, new simple_type(simple_type::string_type)); + IfcDimensionCount_type = new type_declaration(IfcSchema::Type::IfcDimensionCount, new simple_type(simple_type::integer_type)); + IfcDoseEquivalentMeasure_type = new type_declaration(IfcSchema::Type::IfcDoseEquivalentMeasure, new simple_type(simple_type::real_type)); + IfcDynamicViscosityMeasure_type = new type_declaration(IfcSchema::Type::IfcDynamicViscosityMeasure, new simple_type(simple_type::real_type)); + IfcElectricCapacitanceMeasure_type = new type_declaration(IfcSchema::Type::IfcElectricCapacitanceMeasure, new simple_type(simple_type::real_type)); + IfcElectricChargeMeasure_type = new type_declaration(IfcSchema::Type::IfcElectricChargeMeasure, new simple_type(simple_type::real_type)); + IfcElectricConductanceMeasure_type = new type_declaration(IfcSchema::Type::IfcElectricConductanceMeasure, new simple_type(simple_type::real_type)); + IfcElectricCurrentMeasure_type = new type_declaration(IfcSchema::Type::IfcElectricCurrentMeasure, new simple_type(simple_type::real_type)); + IfcElectricResistanceMeasure_type = new type_declaration(IfcSchema::Type::IfcElectricResistanceMeasure, new simple_type(simple_type::real_type)); + IfcElectricVoltageMeasure_type = new type_declaration(IfcSchema::Type::IfcElectricVoltageMeasure, new simple_type(simple_type::real_type)); + IfcEnergyMeasure_type = new type_declaration(IfcSchema::Type::IfcEnergyMeasure, new simple_type(simple_type::real_type)); + IfcFontStyle_type = new type_declaration(IfcSchema::Type::IfcFontStyle, new simple_type(simple_type::string_type)); + IfcFontVariant_type = new type_declaration(IfcSchema::Type::IfcFontVariant, new simple_type(simple_type::string_type)); + IfcFontWeight_type = new type_declaration(IfcSchema::Type::IfcFontWeight, new simple_type(simple_type::string_type)); + IfcForceMeasure_type = new type_declaration(IfcSchema::Type::IfcForceMeasure, new simple_type(simple_type::real_type)); + IfcFrequencyMeasure_type = new type_declaration(IfcSchema::Type::IfcFrequencyMeasure, new simple_type(simple_type::real_type)); + IfcGloballyUniqueId_type = new type_declaration(IfcSchema::Type::IfcGloballyUniqueId, new simple_type(simple_type::string_type)); + IfcHeatFluxDensityMeasure_type = new type_declaration(IfcSchema::Type::IfcHeatFluxDensityMeasure, new simple_type(simple_type::real_type)); + IfcHeatingValueMeasure_type = new type_declaration(IfcSchema::Type::IfcHeatingValueMeasure, new simple_type(simple_type::real_type)); + IfcHourInDay_type = new type_declaration(IfcSchema::Type::IfcHourInDay, new simple_type(simple_type::integer_type)); + IfcIdentifier_type = new type_declaration(IfcSchema::Type::IfcIdentifier, new simple_type(simple_type::string_type)); + IfcIlluminanceMeasure_type = new type_declaration(IfcSchema::Type::IfcIlluminanceMeasure, new simple_type(simple_type::real_type)); + IfcInductanceMeasure_type = new type_declaration(IfcSchema::Type::IfcInductanceMeasure, new simple_type(simple_type::real_type)); + IfcInteger_type = new type_declaration(IfcSchema::Type::IfcInteger, new simple_type(simple_type::integer_type)); + IfcIntegerCountRateMeasure_type = new type_declaration(IfcSchema::Type::IfcIntegerCountRateMeasure, new simple_type(simple_type::integer_type)); + IfcIonConcentrationMeasure_type = new type_declaration(IfcSchema::Type::IfcIonConcentrationMeasure, new simple_type(simple_type::real_type)); + IfcIsothermalMoistureCapacityMeasure_type = new type_declaration(IfcSchema::Type::IfcIsothermalMoistureCapacityMeasure, new simple_type(simple_type::real_type)); + IfcKinematicViscosityMeasure_type = new type_declaration(IfcSchema::Type::IfcKinematicViscosityMeasure, new simple_type(simple_type::real_type)); + IfcLabel_type = new type_declaration(IfcSchema::Type::IfcLabel, new simple_type(simple_type::string_type)); + IfcLengthMeasure_type = new type_declaration(IfcSchema::Type::IfcLengthMeasure, new simple_type(simple_type::real_type)); + IfcLinearForceMeasure_type = new type_declaration(IfcSchema::Type::IfcLinearForceMeasure, new simple_type(simple_type::real_type)); + IfcLinearMomentMeasure_type = new type_declaration(IfcSchema::Type::IfcLinearMomentMeasure, new simple_type(simple_type::real_type)); + IfcLinearStiffnessMeasure_type = new type_declaration(IfcSchema::Type::IfcLinearStiffnessMeasure, new simple_type(simple_type::real_type)); + IfcLinearVelocityMeasure_type = new type_declaration(IfcSchema::Type::IfcLinearVelocityMeasure, new simple_type(simple_type::real_type)); + IfcLogical_type = new type_declaration(IfcSchema::Type::IfcLogical, new simple_type(simple_type::logical_type)); + IfcLuminousFluxMeasure_type = new type_declaration(IfcSchema::Type::IfcLuminousFluxMeasure, new simple_type(simple_type::real_type)); + IfcLuminousIntensityDistributionMeasure_type = new type_declaration(IfcSchema::Type::IfcLuminousIntensityDistributionMeasure, new simple_type(simple_type::real_type)); + IfcLuminousIntensityMeasure_type = new type_declaration(IfcSchema::Type::IfcLuminousIntensityMeasure, new simple_type(simple_type::real_type)); + IfcMagneticFluxDensityMeasure_type = new type_declaration(IfcSchema::Type::IfcMagneticFluxDensityMeasure, new simple_type(simple_type::real_type)); + IfcMagneticFluxMeasure_type = new type_declaration(IfcSchema::Type::IfcMagneticFluxMeasure, new simple_type(simple_type::real_type)); + IfcMassDensityMeasure_type = new type_declaration(IfcSchema::Type::IfcMassDensityMeasure, new simple_type(simple_type::real_type)); + IfcMassFlowRateMeasure_type = new type_declaration(IfcSchema::Type::IfcMassFlowRateMeasure, new simple_type(simple_type::real_type)); + IfcMassMeasure_type = new type_declaration(IfcSchema::Type::IfcMassMeasure, new simple_type(simple_type::real_type)); + IfcMassPerLengthMeasure_type = new type_declaration(IfcSchema::Type::IfcMassPerLengthMeasure, new simple_type(simple_type::real_type)); + IfcMinuteInHour_type = new type_declaration(IfcSchema::Type::IfcMinuteInHour, new simple_type(simple_type::integer_type)); + IfcModulusOfElasticityMeasure_type = new type_declaration(IfcSchema::Type::IfcModulusOfElasticityMeasure, new simple_type(simple_type::real_type)); + IfcModulusOfLinearSubgradeReactionMeasure_type = new type_declaration(IfcSchema::Type::IfcModulusOfLinearSubgradeReactionMeasure, new simple_type(simple_type::real_type)); + IfcModulusOfRotationalSubgradeReactionMeasure_type = new type_declaration(IfcSchema::Type::IfcModulusOfRotationalSubgradeReactionMeasure, new simple_type(simple_type::real_type)); + IfcModulusOfSubgradeReactionMeasure_type = new type_declaration(IfcSchema::Type::IfcModulusOfSubgradeReactionMeasure, new simple_type(simple_type::real_type)); + IfcMoistureDiffusivityMeasure_type = new type_declaration(IfcSchema::Type::IfcMoistureDiffusivityMeasure, new simple_type(simple_type::real_type)); + IfcMolecularWeightMeasure_type = new type_declaration(IfcSchema::Type::IfcMolecularWeightMeasure, new simple_type(simple_type::real_type)); + IfcMomentOfInertiaMeasure_type = new type_declaration(IfcSchema::Type::IfcMomentOfInertiaMeasure, new simple_type(simple_type::real_type)); + IfcMonetaryMeasure_type = new type_declaration(IfcSchema::Type::IfcMonetaryMeasure, new simple_type(simple_type::real_type)); + IfcMonthInYearNumber_type = new type_declaration(IfcSchema::Type::IfcMonthInYearNumber, new simple_type(simple_type::integer_type)); + IfcNumericMeasure_type = new type_declaration(IfcSchema::Type::IfcNumericMeasure, new simple_type(simple_type::number_type)); + IfcPHMeasure_type = new type_declaration(IfcSchema::Type::IfcPHMeasure, new simple_type(simple_type::real_type)); + IfcParameterValue_type = new type_declaration(IfcSchema::Type::IfcParameterValue, new simple_type(simple_type::real_type)); + IfcPlanarForceMeasure_type = new type_declaration(IfcSchema::Type::IfcPlanarForceMeasure, new simple_type(simple_type::real_type)); + IfcPlaneAngleMeasure_type = new type_declaration(IfcSchema::Type::IfcPlaneAngleMeasure, new simple_type(simple_type::real_type)); + IfcPositiveLengthMeasure_type = new type_declaration(IfcSchema::Type::IfcPositiveLengthMeasure, new named_type(IfcLengthMeasure_type)); + IfcPositivePlaneAngleMeasure_type = new type_declaration(IfcSchema::Type::IfcPositivePlaneAngleMeasure, new named_type(IfcPlaneAngleMeasure_type)); + IfcPowerMeasure_type = new type_declaration(IfcSchema::Type::IfcPowerMeasure, new simple_type(simple_type::real_type)); + IfcPresentableText_type = new type_declaration(IfcSchema::Type::IfcPresentableText, new simple_type(simple_type::string_type)); + IfcPressureMeasure_type = new type_declaration(IfcSchema::Type::IfcPressureMeasure, new simple_type(simple_type::real_type)); + IfcRadioActivityMeasure_type = new type_declaration(IfcSchema::Type::IfcRadioActivityMeasure, new simple_type(simple_type::real_type)); + IfcRatioMeasure_type = new type_declaration(IfcSchema::Type::IfcRatioMeasure, new simple_type(simple_type::real_type)); + IfcReal_type = new type_declaration(IfcSchema::Type::IfcReal, new simple_type(simple_type::real_type)); + IfcRotationalFrequencyMeasure_type = new type_declaration(IfcSchema::Type::IfcRotationalFrequencyMeasure, new simple_type(simple_type::real_type)); + IfcRotationalMassMeasure_type = new type_declaration(IfcSchema::Type::IfcRotationalMassMeasure, new simple_type(simple_type::real_type)); + IfcRotationalStiffnessMeasure_type = new type_declaration(IfcSchema::Type::IfcRotationalStiffnessMeasure, new simple_type(simple_type::real_type)); + IfcSecondInMinute_type = new type_declaration(IfcSchema::Type::IfcSecondInMinute, new simple_type(simple_type::real_type)); + IfcSectionModulusMeasure_type = new type_declaration(IfcSchema::Type::IfcSectionModulusMeasure, new simple_type(simple_type::real_type)); + IfcSectionalAreaIntegralMeasure_type = new type_declaration(IfcSchema::Type::IfcSectionalAreaIntegralMeasure, new simple_type(simple_type::real_type)); + IfcShearModulusMeasure_type = new type_declaration(IfcSchema::Type::IfcShearModulusMeasure, new simple_type(simple_type::real_type)); + IfcSolidAngleMeasure_type = new type_declaration(IfcSchema::Type::IfcSolidAngleMeasure, new simple_type(simple_type::real_type)); + IfcSoundPowerMeasure_type = new type_declaration(IfcSchema::Type::IfcSoundPowerMeasure, new simple_type(simple_type::real_type)); + IfcSoundPressureMeasure_type = new type_declaration(IfcSchema::Type::IfcSoundPressureMeasure, new simple_type(simple_type::real_type)); + IfcSpecificHeatCapacityMeasure_type = new type_declaration(IfcSchema::Type::IfcSpecificHeatCapacityMeasure, new simple_type(simple_type::real_type)); + IfcSpecularExponent_type = new type_declaration(IfcSchema::Type::IfcSpecularExponent, new simple_type(simple_type::real_type)); + IfcSpecularRoughness_type = new type_declaration(IfcSchema::Type::IfcSpecularRoughness, new simple_type(simple_type::real_type)); + IfcTemperatureGradientMeasure_type = new type_declaration(IfcSchema::Type::IfcTemperatureGradientMeasure, new simple_type(simple_type::real_type)); + IfcText_type = new type_declaration(IfcSchema::Type::IfcText, new simple_type(simple_type::string_type)); + IfcTextAlignment_type = new type_declaration(IfcSchema::Type::IfcTextAlignment, new simple_type(simple_type::string_type)); + IfcTextDecoration_type = new type_declaration(IfcSchema::Type::IfcTextDecoration, new simple_type(simple_type::string_type)); + IfcTextFontName_type = new type_declaration(IfcSchema::Type::IfcTextFontName, new simple_type(simple_type::string_type)); + IfcTextTransformation_type = new type_declaration(IfcSchema::Type::IfcTextTransformation, new simple_type(simple_type::string_type)); + IfcThermalAdmittanceMeasure_type = new type_declaration(IfcSchema::Type::IfcThermalAdmittanceMeasure, new simple_type(simple_type::real_type)); + IfcThermalConductivityMeasure_type = new type_declaration(IfcSchema::Type::IfcThermalConductivityMeasure, new simple_type(simple_type::real_type)); + IfcThermalExpansionCoefficientMeasure_type = new type_declaration(IfcSchema::Type::IfcThermalExpansionCoefficientMeasure, new simple_type(simple_type::real_type)); + IfcThermalResistanceMeasure_type = new type_declaration(IfcSchema::Type::IfcThermalResistanceMeasure, new simple_type(simple_type::real_type)); + IfcThermalTransmittanceMeasure_type = new type_declaration(IfcSchema::Type::IfcThermalTransmittanceMeasure, new simple_type(simple_type::real_type)); + IfcThermodynamicTemperatureMeasure_type = new type_declaration(IfcSchema::Type::IfcThermodynamicTemperatureMeasure, new simple_type(simple_type::real_type)); + IfcTimeMeasure_type = new type_declaration(IfcSchema::Type::IfcTimeMeasure, new simple_type(simple_type::real_type)); + IfcTimeStamp_type = new type_declaration(IfcSchema::Type::IfcTimeStamp, new simple_type(simple_type::integer_type)); + IfcTorqueMeasure_type = new type_declaration(IfcSchema::Type::IfcTorqueMeasure, new simple_type(simple_type::real_type)); + IfcVaporPermeabilityMeasure_type = new type_declaration(IfcSchema::Type::IfcVaporPermeabilityMeasure, new simple_type(simple_type::real_type)); + IfcVolumeMeasure_type = new type_declaration(IfcSchema::Type::IfcVolumeMeasure, new simple_type(simple_type::real_type)); + IfcVolumetricFlowRateMeasure_type = new type_declaration(IfcSchema::Type::IfcVolumetricFlowRateMeasure, new simple_type(simple_type::real_type)); + IfcWarpingConstantMeasure_type = new type_declaration(IfcSchema::Type::IfcWarpingConstantMeasure, new simple_type(simple_type::real_type)); + IfcWarpingMomentMeasure_type = new type_declaration(IfcSchema::Type::IfcWarpingMomentMeasure, new simple_type(simple_type::real_type)); + IfcYearNumber_type = new type_declaration(IfcSchema::Type::IfcYearNumber, new simple_type(simple_type::integer_type)); + IfcBoxAlignment_type = new type_declaration(IfcSchema::Type::IfcBoxAlignment, new named_type(IfcLabel_type)); + IfcNormalisedRatioMeasure_type = new type_declaration(IfcSchema::Type::IfcNormalisedRatioMeasure, new named_type(IfcRatioMeasure_type)); + IfcPositiveRatioMeasure_type = new type_declaration(IfcSchema::Type::IfcPositiveRatioMeasure, new named_type(IfcRatioMeasure_type)); { std::vector items; items.reserve(27); items.push_back("BRAKES"); @@ -176,9 +1156,8 @@ void populate() { items.push_back("USERDEFINED"); items.push_back("WAVE"); items.push_back("WIND_W"); - IfcActionSourceTypeEnum_type = new enumeration_type("IfcActionSourceTypeEnum", items); + IfcActionSourceTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcActionSourceTypeEnum, items); } - declaration* IfcActionTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("EXTRAORDINARY_A"); @@ -186,9 +1165,8 @@ void populate() { items.push_back("PERMANENT_G"); items.push_back("USERDEFINED"); items.push_back("VARIABLE_Q"); - IfcActionTypeEnum_type = new enumeration_type("IfcActionTypeEnum", items); + IfcActionTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcActionTypeEnum, items); } - declaration* IfcActuatorTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("ELECTRICACTUATOR"); @@ -198,9 +1176,8 @@ void populate() { items.push_back("PNEUMATICACTUATOR"); items.push_back("THERMOSTATICACTUATOR"); items.push_back("USERDEFINED"); - IfcActuatorTypeEnum_type = new enumeration_type("IfcActuatorTypeEnum", items); + IfcActuatorTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcActuatorTypeEnum, items); } - declaration* IfcAddressTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("DISTRIBUTIONPOINT"); @@ -208,16 +1185,14 @@ void populate() { items.push_back("OFFICE"); items.push_back("SITE"); items.push_back("USERDEFINED"); - IfcAddressTypeEnum_type = new enumeration_type("IfcAddressTypeEnum", items); + IfcAddressTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcAddressTypeEnum, items); } - declaration* IfcAheadOrBehind_type; { std::vector items; items.reserve(2); items.push_back("AHEAD"); items.push_back("BEHIND"); - IfcAheadOrBehind_type = new enumeration_type("IfcAheadOrBehind", items); + IfcAheadOrBehind_type = new enumeration_type(IfcSchema::Type::IfcAheadOrBehind, items); } - declaration* IfcAirTerminalBoxTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("CONSTANTFLOW"); @@ -225,9 +1200,8 @@ void populate() { items.push_back("USERDEFINED"); items.push_back("VARIABLEFLOWPRESSUREDEPENDANT"); items.push_back("VARIABLEFLOWPRESSUREINDEPENDANT"); - IfcAirTerminalBoxTypeEnum_type = new enumeration_type("IfcAirTerminalBoxTypeEnum", items); + IfcAirTerminalBoxTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcAirTerminalBoxTypeEnum, items); } - declaration* IfcAirTerminalTypeEnum_type; { std::vector items; items.reserve(9); items.push_back("DIFFUSER"); @@ -239,9 +1213,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("REGISTER"); items.push_back("USERDEFINED"); - IfcAirTerminalTypeEnum_type = new enumeration_type("IfcAirTerminalTypeEnum", items); + IfcAirTerminalTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcAirTerminalTypeEnum, items); } - declaration* IfcAirToAirHeatRecoveryTypeEnum_type; { std::vector items; items.reserve(11); items.push_back("FIXEDPLATECOUNTERFLOWEXCHANGER"); @@ -255,9 +1228,8 @@ void populate() { items.push_back("THERMOSIPHONSEALEDTUBEHEATEXCHANGERS"); items.push_back("TWINTOWERENTHALPYRECOVERYLOOPS"); items.push_back("USERDEFINED"); - IfcAirToAirHeatRecoveryTypeEnum_type = new enumeration_type("IfcAirToAirHeatRecoveryTypeEnum", items); + IfcAirToAirHeatRecoveryTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcAirToAirHeatRecoveryTypeEnum, items); } - declaration* IfcAlarmTypeEnum_type; { std::vector items; items.reserve(8); items.push_back("BELL"); @@ -268,9 +1240,8 @@ void populate() { items.push_back("SIREN"); items.push_back("USERDEFINED"); items.push_back("WHISTLE"); - IfcAlarmTypeEnum_type = new enumeration_type("IfcAlarmTypeEnum", items); + IfcAlarmTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcAlarmTypeEnum, items); } - declaration* IfcAnalysisModelTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("IN_PLANE_LOADING_2D"); @@ -278,9 +1249,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("OUT_PLANE_LOADING_2D"); items.push_back("USERDEFINED"); - IfcAnalysisModelTypeEnum_type = new enumeration_type("IfcAnalysisModelTypeEnum", items); + IfcAnalysisModelTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcAnalysisModelTypeEnum, items); } - declaration* IfcAnalysisTheoryTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("FIRST_ORDER_THEORY"); @@ -289,26 +1259,23 @@ void populate() { items.push_back("SECOND_ORDER_THEORY"); items.push_back("THIRD_ORDER_THEORY"); items.push_back("USERDEFINED"); - IfcAnalysisTheoryTypeEnum_type = new enumeration_type("IfcAnalysisTheoryTypeEnum", items); + IfcAnalysisTheoryTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcAnalysisTheoryTypeEnum, items); } - declaration* IfcArithmeticOperatorEnum_type; { std::vector items; items.reserve(4); items.push_back("ADD"); items.push_back("DIVIDE"); items.push_back("MULTIPLY"); items.push_back("SUBTRACT"); - IfcArithmeticOperatorEnum_type = new enumeration_type("IfcArithmeticOperatorEnum", items); + IfcArithmeticOperatorEnum_type = new enumeration_type(IfcSchema::Type::IfcArithmeticOperatorEnum, items); } - declaration* IfcAssemblyPlaceEnum_type; { std::vector items; items.reserve(3); items.push_back("FACTORY"); items.push_back("NOTDEFINED"); items.push_back("SITE"); - IfcAssemblyPlaceEnum_type = new enumeration_type("IfcAssemblyPlaceEnum", items); + IfcAssemblyPlaceEnum_type = new enumeration_type(IfcSchema::Type::IfcAssemblyPlaceEnum, items); } - declaration* IfcBSplineCurveForm_type; { std::vector items; items.reserve(6); items.push_back("CIRCULAR_ARC"); @@ -317,9 +1284,8 @@ void populate() { items.push_back("PARABOLIC_ARC"); items.push_back("POLYLINE_FORM"); items.push_back("UNSPECIFIED"); - IfcBSplineCurveForm_type = new enumeration_type("IfcBSplineCurveForm", items); + IfcBSplineCurveForm_type = new enumeration_type(IfcSchema::Type::IfcBSplineCurveForm, items); } - declaration* IfcBeamTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("BEAM"); @@ -328,9 +1294,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("T_BEAM"); items.push_back("USERDEFINED"); - IfcBeamTypeEnum_type = new enumeration_type("IfcBeamTypeEnum", items); + IfcBeamTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcBeamTypeEnum, items); } - declaration* IfcBenchmarkEnum_type; { std::vector items; items.reserve(6); items.push_back("EQUALTO"); @@ -339,33 +1304,29 @@ void populate() { items.push_back("LESSTHAN"); items.push_back("LESSTHANOREQUALTO"); items.push_back("NOTEQUALTO"); - IfcBenchmarkEnum_type = new enumeration_type("IfcBenchmarkEnum", items); + IfcBenchmarkEnum_type = new enumeration_type(IfcSchema::Type::IfcBenchmarkEnum, items); } - declaration* IfcBoilerTypeEnum_type; { std::vector items; items.reserve(4); items.push_back("NOTDEFINED"); items.push_back("STEAM"); items.push_back("USERDEFINED"); items.push_back("WATER"); - IfcBoilerTypeEnum_type = new enumeration_type("IfcBoilerTypeEnum", items); + IfcBoilerTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcBoilerTypeEnum, items); } - declaration* IfcBooleanOperator_type; { std::vector items; items.reserve(3); items.push_back("DIFFERENCE"); items.push_back("INTERSECTION"); items.push_back("UNION"); - IfcBooleanOperator_type = new enumeration_type("IfcBooleanOperator", items); + IfcBooleanOperator_type = new enumeration_type(IfcSchema::Type::IfcBooleanOperator, items); } - declaration* IfcBuildingElementProxyTypeEnum_type; { std::vector items; items.reserve(2); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcBuildingElementProxyTypeEnum_type = new enumeration_type("IfcBuildingElementProxyTypeEnum", items); + IfcBuildingElementProxyTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcBuildingElementProxyTypeEnum, items); } - declaration* IfcCableCarrierFittingTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("BEND"); @@ -374,9 +1335,8 @@ void populate() { items.push_back("REDUCER"); items.push_back("TEE"); items.push_back("USERDEFINED"); - IfcCableCarrierFittingTypeEnum_type = new enumeration_type("IfcCableCarrierFittingTypeEnum", items); + IfcCableCarrierFittingTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcCableCarrierFittingTypeEnum, items); } - declaration* IfcCableCarrierSegmentTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("CABLELADDERSEGMENT"); @@ -385,18 +1345,16 @@ void populate() { items.push_back("CONDUITSEGMENT"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcCableCarrierSegmentTypeEnum_type = new enumeration_type("IfcCableCarrierSegmentTypeEnum", items); + IfcCableCarrierSegmentTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcCableCarrierSegmentTypeEnum, items); } - declaration* IfcCableSegmentTypeEnum_type; { std::vector items; items.reserve(4); items.push_back("CABLESEGMENT"); items.push_back("CONDUCTORSEGMENT"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcCableSegmentTypeEnum_type = new enumeration_type("IfcCableSegmentTypeEnum", items); + IfcCableSegmentTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcCableSegmentTypeEnum, items); } - declaration* IfcChangeActionEnum_type; { std::vector items; items.reserve(6); items.push_back("ADDED"); @@ -405,9 +1363,8 @@ void populate() { items.push_back("MODIFIEDADDED"); items.push_back("MODIFIEDDELETED"); items.push_back("NOCHANGE"); - IfcChangeActionEnum_type = new enumeration_type("IfcChangeActionEnum", items); + IfcChangeActionEnum_type = new enumeration_type(IfcSchema::Type::IfcChangeActionEnum, items); } - declaration* IfcChillerTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("AIRCOOLED"); @@ -415,9 +1372,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); items.push_back("WATERCOOLED"); - IfcChillerTypeEnum_type = new enumeration_type("IfcChillerTypeEnum", items); + IfcChillerTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcChillerTypeEnum, items); } - declaration* IfcCoilTypeEnum_type; { std::vector items; items.reserve(8); items.push_back("DXCOOLINGCOIL"); @@ -428,17 +1384,15 @@ void populate() { items.push_back("USERDEFINED"); items.push_back("WATERCOOLINGCOIL"); items.push_back("WATERHEATINGCOIL"); - IfcCoilTypeEnum_type = new enumeration_type("IfcCoilTypeEnum", items); + IfcCoilTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcCoilTypeEnum, items); } - declaration* IfcColumnTypeEnum_type; { std::vector items; items.reserve(3); items.push_back("COLUMN"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcColumnTypeEnum_type = new enumeration_type("IfcColumnTypeEnum", items); + IfcColumnTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcColumnTypeEnum, items); } - declaration* IfcCompressorTypeEnum_type; { std::vector items; items.reserve(17); items.push_back("BOOSTER"); @@ -458,9 +1412,8 @@ void populate() { items.push_back("TWINSCREW"); items.push_back("USERDEFINED"); items.push_back("WELDEDSHELLHERMETIC"); - IfcCompressorTypeEnum_type = new enumeration_type("IfcCompressorTypeEnum", items); + IfcCompressorTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcCompressorTypeEnum, items); } - declaration* IfcCondenserTypeEnum_type; { std::vector items; items.reserve(8); items.push_back("AIRCOOLED"); @@ -471,18 +1424,16 @@ void populate() { items.push_back("WATERCOOLEDSHELLCOIL"); items.push_back("WATERCOOLEDSHELLTUBE"); items.push_back("WATERCOOLEDTUBEINTUBE"); - IfcCondenserTypeEnum_type = new enumeration_type("IfcCondenserTypeEnum", items); + IfcCondenserTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcCondenserTypeEnum, items); } - declaration* IfcConnectionTypeEnum_type; { std::vector items; items.reserve(4); items.push_back("ATEND"); items.push_back("ATPATH"); items.push_back("ATSTART"); items.push_back("NOTDEFINED"); - IfcConnectionTypeEnum_type = new enumeration_type("IfcConnectionTypeEnum", items); + IfcConnectionTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcConnectionTypeEnum, items); } - declaration* IfcConstraintEnum_type; { std::vector items; items.reserve(5); items.push_back("ADVISORY"); @@ -490,9 +1441,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("SOFT"); items.push_back("USERDEFINED"); - IfcConstraintEnum_type = new enumeration_type("IfcConstraintEnum", items); + IfcConstraintEnum_type = new enumeration_type(IfcSchema::Type::IfcConstraintEnum, items); } - declaration* IfcControllerTypeEnum_type; { std::vector items; items.reserve(8); items.push_back("FLOATING"); @@ -503,18 +1453,16 @@ void populate() { items.push_back("TIMEDTWOPOSITION"); items.push_back("TWOPOSITION"); items.push_back("USERDEFINED"); - IfcControllerTypeEnum_type = new enumeration_type("IfcControllerTypeEnum", items); + IfcControllerTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcControllerTypeEnum, items); } - declaration* IfcCooledBeamTypeEnum_type; { std::vector items; items.reserve(4); items.push_back("ACTIVE"); items.push_back("NOTDEFINED"); items.push_back("PASSIVE"); items.push_back("USERDEFINED"); - IfcCooledBeamTypeEnum_type = new enumeration_type("IfcCooledBeamTypeEnum", items); + IfcCooledBeamTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcCooledBeamTypeEnum, items); } - declaration* IfcCoolingTowerTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("MECHANICALFORCEDDRAFT"); @@ -522,9 +1470,8 @@ void populate() { items.push_back("NATURALDRAFT"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcCoolingTowerTypeEnum_type = new enumeration_type("IfcCoolingTowerTypeEnum", items); + IfcCoolingTowerTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcCoolingTowerTypeEnum, items); } - declaration* IfcCostScheduleTypeEnum_type; { std::vector items; items.reserve(9); items.push_back("BUDGET"); @@ -536,9 +1483,8 @@ void populate() { items.push_back("TENDER"); items.push_back("UNPRICEDBILLOFQUANTITIES"); items.push_back("USERDEFINED"); - IfcCostScheduleTypeEnum_type = new enumeration_type("IfcCostScheduleTypeEnum", items); + IfcCostScheduleTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcCostScheduleTypeEnum, items); } - declaration* IfcCoveringTypeEnum_type; { std::vector items; items.reserve(10); items.push_back("CEILING"); @@ -551,9 +1497,8 @@ void populate() { items.push_back("SLEEVING"); items.push_back("USERDEFINED"); items.push_back("WRAPPING"); - IfcCoveringTypeEnum_type = new enumeration_type("IfcCoveringTypeEnum", items); + IfcCoveringTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcCoveringTypeEnum, items); } - declaration* IfcCurrencyEnum_type; { std::vector items; items.reserve(83); items.push_back("AED"); @@ -639,16 +1584,14 @@ void populate() { items.push_back("XEU"); items.push_back("ZAR"); items.push_back("ZWD"); - IfcCurrencyEnum_type = new enumeration_type("IfcCurrencyEnum", items); + IfcCurrencyEnum_type = new enumeration_type(IfcSchema::Type::IfcCurrencyEnum, items); } - declaration* IfcCurtainWallTypeEnum_type; { std::vector items; items.reserve(2); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcCurtainWallTypeEnum_type = new enumeration_type("IfcCurtainWallTypeEnum", items); + IfcCurtainWallTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcCurtainWallTypeEnum, items); } - declaration* IfcDamperTypeEnum_type; { std::vector items; items.reserve(13); items.push_back("BACKDRAFTDAMPER"); @@ -664,9 +1607,8 @@ void populate() { items.push_back("RELIEFDAMPER"); items.push_back("SMOKEDAMPER"); items.push_back("USERDEFINED"); - IfcDamperTypeEnum_type = new enumeration_type("IfcDamperTypeEnum", items); + IfcDamperTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcDamperTypeEnum, items); } - declaration* IfcDataOriginEnum_type; { std::vector items; items.reserve(5); items.push_back("MEASURED"); @@ -674,9 +1616,8 @@ void populate() { items.push_back("PREDICTED"); items.push_back("SIMULATED"); items.push_back("USERDEFINED"); - IfcDataOriginEnum_type = new enumeration_type("IfcDataOriginEnum", items); + IfcDataOriginEnum_type = new enumeration_type(IfcSchema::Type::IfcDataOriginEnum, items); } - declaration* IfcDerivedUnitEnum_type; { std::vector items; items.reserve(49); items.push_back("ACCELERATIONUNIT"); @@ -728,23 +1669,20 @@ void populate() { items.push_back("VOLUMETRICFLOWRATEUNIT"); items.push_back("WARPINGCONSTANTUNIT"); items.push_back("WARPINGMOMENTUNIT"); - IfcDerivedUnitEnum_type = new enumeration_type("IfcDerivedUnitEnum", items); + IfcDerivedUnitEnum_type = new enumeration_type(IfcSchema::Type::IfcDerivedUnitEnum, items); } - declaration* IfcDimensionExtentUsage_type; { std::vector items; items.reserve(2); items.push_back("ORIGIN"); items.push_back("TARGET"); - IfcDimensionExtentUsage_type = new enumeration_type("IfcDimensionExtentUsage", items); + IfcDimensionExtentUsage_type = new enumeration_type(IfcSchema::Type::IfcDimensionExtentUsage, items); } - declaration* IfcDirectionSenseEnum_type; { std::vector items; items.reserve(2); items.push_back("NEGATIVE"); items.push_back("POSITIVE"); - IfcDirectionSenseEnum_type = new enumeration_type("IfcDirectionSenseEnum", items); + IfcDirectionSenseEnum_type = new enumeration_type(IfcSchema::Type::IfcDirectionSenseEnum, items); } - declaration* IfcDistributionChamberElementTypeEnum_type; { std::vector items; items.reserve(10); items.push_back("FORMEDDUCT"); @@ -757,9 +1695,8 @@ void populate() { items.push_back("TRENCH"); items.push_back("USERDEFINED"); items.push_back("VALVECHAMBER"); - IfcDistributionChamberElementTypeEnum_type = new enumeration_type("IfcDistributionChamberElementTypeEnum", items); + IfcDistributionChamberElementTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcDistributionChamberElementTypeEnum, items); } - declaration* IfcDocumentConfidentialityEnum_type; { std::vector items; items.reserve(6); items.push_back("CONFIDENTIAL"); @@ -768,9 +1705,8 @@ void populate() { items.push_back("PUBLIC"); items.push_back("RESTRICTED"); items.push_back("USERDEFINED"); - IfcDocumentConfidentialityEnum_type = new enumeration_type("IfcDocumentConfidentialityEnum", items); + IfcDocumentConfidentialityEnum_type = new enumeration_type(IfcSchema::Type::IfcDocumentConfidentialityEnum, items); } - declaration* IfcDocumentStatusEnum_type; { std::vector items; items.reserve(5); items.push_back("DRAFT"); @@ -778,9 +1714,8 @@ void populate() { items.push_back("FINALDRAFT"); items.push_back("NOTDEFINED"); items.push_back("REVISION"); - IfcDocumentStatusEnum_type = new enumeration_type("IfcDocumentStatusEnum", items); + IfcDocumentStatusEnum_type = new enumeration_type(IfcSchema::Type::IfcDocumentStatusEnum, items); } - declaration* IfcDoorPanelOperationEnum_type; { std::vector items; items.reserve(8); items.push_back("DOUBLE_ACTING"); @@ -791,18 +1726,16 @@ void populate() { items.push_back("SLIDING"); items.push_back("SWINGING"); items.push_back("USERDEFINED"); - IfcDoorPanelOperationEnum_type = new enumeration_type("IfcDoorPanelOperationEnum", items); + IfcDoorPanelOperationEnum_type = new enumeration_type(IfcSchema::Type::IfcDoorPanelOperationEnum, items); } - declaration* IfcDoorPanelPositionEnum_type; { std::vector items; items.reserve(4); items.push_back("LEFT"); items.push_back("MIDDLE"); items.push_back("NOTDEFINED"); items.push_back("RIGHT"); - IfcDoorPanelPositionEnum_type = new enumeration_type("IfcDoorPanelPositionEnum", items); + IfcDoorPanelPositionEnum_type = new enumeration_type(IfcSchema::Type::IfcDoorPanelPositionEnum, items); } - declaration* IfcDoorStyleConstructionEnum_type; { std::vector items; items.reserve(9); items.push_back("ALUMINIUM"); @@ -814,9 +1747,8 @@ void populate() { items.push_back("STEEL"); items.push_back("USERDEFINED"); items.push_back("WOOD"); - IfcDoorStyleConstructionEnum_type = new enumeration_type("IfcDoorStyleConstructionEnum", items); + IfcDoorStyleConstructionEnum_type = new enumeration_type(IfcSchema::Type::IfcDoorStyleConstructionEnum, items); } - declaration* IfcDoorStyleOperationEnum_type; { std::vector items; items.reserve(18); items.push_back("DOUBLE_DOOR_DOUBLE_SWING"); @@ -837,9 +1769,8 @@ void populate() { items.push_back("SLIDING_TO_LEFT"); items.push_back("SLIDING_TO_RIGHT"); items.push_back("USERDEFINED"); - IfcDoorStyleOperationEnum_type = new enumeration_type("IfcDoorStyleOperationEnum", items); + IfcDoorStyleOperationEnum_type = new enumeration_type(IfcSchema::Type::IfcDoorStyleOperationEnum, items); } - declaration* IfcDuctFittingTypeEnum_type; { std::vector items; items.reserve(9); items.push_back("BEND"); @@ -851,18 +1782,16 @@ void populate() { items.push_back("OBSTRUCTION"); items.push_back("TRANSITION"); items.push_back("USERDEFINED"); - IfcDuctFittingTypeEnum_type = new enumeration_type("IfcDuctFittingTypeEnum", items); + IfcDuctFittingTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcDuctFittingTypeEnum, items); } - declaration* IfcDuctSegmentTypeEnum_type; { std::vector items; items.reserve(4); items.push_back("FLEXIBLESEGMENT"); items.push_back("NOTDEFINED"); items.push_back("RIGIDSEGMENT"); items.push_back("USERDEFINED"); - IfcDuctSegmentTypeEnum_type = new enumeration_type("IfcDuctSegmentTypeEnum", items); + IfcDuctSegmentTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcDuctSegmentTypeEnum, items); } - declaration* IfcDuctSilencerTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("FLATOVAL"); @@ -870,9 +1799,8 @@ void populate() { items.push_back("RECTANGULAR"); items.push_back("ROUND"); items.push_back("USERDEFINED"); - IfcDuctSilencerTypeEnum_type = new enumeration_type("IfcDuctSilencerTypeEnum", items); + IfcDuctSilencerTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcDuctSilencerTypeEnum, items); } - declaration* IfcElectricApplianceTypeEnum_type; { std::vector items; items.reserve(26); items.push_back("COMPUTER"); @@ -901,17 +1829,15 @@ void populate() { items.push_back("WASHINGMACHINE"); items.push_back("WATERCOOLER"); items.push_back("WATERHEATER"); - IfcElectricApplianceTypeEnum_type = new enumeration_type("IfcElectricApplianceTypeEnum", items); + IfcElectricApplianceTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcElectricApplianceTypeEnum, items); } - declaration* IfcElectricCurrentEnum_type; { std::vector items; items.reserve(3); items.push_back("ALTERNATING"); items.push_back("DIRECT"); items.push_back("NOTDEFINED"); - IfcElectricCurrentEnum_type = new enumeration_type("IfcElectricCurrentEnum", items); + IfcElectricCurrentEnum_type = new enumeration_type(IfcSchema::Type::IfcElectricCurrentEnum, items); } - declaration* IfcElectricDistributionPointFunctionEnum_type; { std::vector items; items.reserve(11); items.push_back("ALARMPANEL"); @@ -925,9 +1851,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("SWITCHBOARD"); items.push_back("USERDEFINED"); - IfcElectricDistributionPointFunctionEnum_type = new enumeration_type("IfcElectricDistributionPointFunctionEnum", items); + IfcElectricDistributionPointFunctionEnum_type = new enumeration_type(IfcSchema::Type::IfcElectricDistributionPointFunctionEnum, items); } - declaration* IfcElectricFlowStorageDeviceTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("BATTERY"); @@ -937,16 +1862,14 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("UPS"); items.push_back("USERDEFINED"); - IfcElectricFlowStorageDeviceTypeEnum_type = new enumeration_type("IfcElectricFlowStorageDeviceTypeEnum", items); + IfcElectricFlowStorageDeviceTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcElectricFlowStorageDeviceTypeEnum, items); } - declaration* IfcElectricGeneratorTypeEnum_type; { std::vector items; items.reserve(2); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcElectricGeneratorTypeEnum_type = new enumeration_type("IfcElectricGeneratorTypeEnum", items); + IfcElectricGeneratorTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcElectricGeneratorTypeEnum, items); } - declaration* IfcElectricHeaterTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("ELECTRICCABLEHEATER"); @@ -954,9 +1877,8 @@ void populate() { items.push_back("ELECTRICPOINTHEATER"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcElectricHeaterTypeEnum_type = new enumeration_type("IfcElectricHeaterTypeEnum", items); + IfcElectricHeaterTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcElectricHeaterTypeEnum, items); } - declaration* IfcElectricMotorTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("DC"); @@ -966,9 +1888,8 @@ void populate() { items.push_back("RELUCTANCESYNCHRONOUS"); items.push_back("SYNCHRONOUS"); items.push_back("USERDEFINED"); - IfcElectricMotorTypeEnum_type = new enumeration_type("IfcElectricMotorTypeEnum", items); + IfcElectricMotorTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcElectricMotorTypeEnum, items); } - declaration* IfcElectricTimeControlTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("NOTDEFINED"); @@ -976,9 +1897,8 @@ void populate() { items.push_back("TIMECLOCK"); items.push_back("TIMEDELAY"); items.push_back("USERDEFINED"); - IfcElectricTimeControlTypeEnum_type = new enumeration_type("IfcElectricTimeControlTypeEnum", items); + IfcElectricTimeControlTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcElectricTimeControlTypeEnum, items); } - declaration* IfcElementAssemblyTypeEnum_type; { std::vector items; items.reserve(11); items.push_back("ACCESSORY_ASSEMBLY"); @@ -992,17 +1912,15 @@ void populate() { items.push_back("SLAB_FIELD"); items.push_back("TRUSS"); items.push_back("USERDEFINED"); - IfcElementAssemblyTypeEnum_type = new enumeration_type("IfcElementAssemblyTypeEnum", items); + IfcElementAssemblyTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcElementAssemblyTypeEnum, items); } - declaration* IfcElementCompositionEnum_type; { std::vector items; items.reserve(3); items.push_back("COMPLEX"); items.push_back("ELEMENT"); items.push_back("PARTIAL"); - IfcElementCompositionEnum_type = new enumeration_type("IfcElementCompositionEnum", items); + IfcElementCompositionEnum_type = new enumeration_type(IfcSchema::Type::IfcElementCompositionEnum, items); } - declaration* IfcEnergySequenceEnum_type; { std::vector items; items.reserve(6); items.push_back("AUXILIARY"); @@ -1011,9 +1929,8 @@ void populate() { items.push_back("SECONDARY"); items.push_back("TERTIARY"); items.push_back("USERDEFINED"); - IfcEnergySequenceEnum_type = new enumeration_type("IfcEnergySequenceEnum", items); + IfcEnergySequenceEnum_type = new enumeration_type(IfcSchema::Type::IfcEnergySequenceEnum, items); } - declaration* IfcEnvironmentalImpactCategoryEnum_type; { std::vector items; items.reserve(8); items.push_back("COMBINEDVALUE"); @@ -1024,9 +1941,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("TRANSPORTATION"); items.push_back("USERDEFINED"); - IfcEnvironmentalImpactCategoryEnum_type = new enumeration_type("IfcEnvironmentalImpactCategoryEnum", items); + IfcEnvironmentalImpactCategoryEnum_type = new enumeration_type(IfcSchema::Type::IfcEnvironmentalImpactCategoryEnum, items); } - declaration* IfcEvaporativeCoolerTypeEnum_type; { std::vector items; items.reserve(11); items.push_back("DIRECTEVAPORATIVEAIRWASHER"); @@ -1040,9 +1956,8 @@ void populate() { items.push_back("INDIRECTEVAPORATIVEWETCOIL"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcEvaporativeCoolerTypeEnum_type = new enumeration_type("IfcEvaporativeCoolerTypeEnum", items); + IfcEvaporativeCoolerTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcEvaporativeCoolerTypeEnum, items); } - declaration* IfcEvaporatorTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("DIRECTEXPANSIONBRAZEDPLATE"); @@ -1052,9 +1967,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("SHELLANDCOIL"); items.push_back("USERDEFINED"); - IfcEvaporatorTypeEnum_type = new enumeration_type("IfcEvaporatorTypeEnum", items); + IfcEvaporatorTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcEvaporatorTypeEnum, items); } - declaration* IfcFanTypeEnum_type; { std::vector items; items.reserve(9); items.push_back("CENTRIFUGALAIRFOIL"); @@ -1066,9 +1980,8 @@ void populate() { items.push_back("TUBEAXIAL"); items.push_back("USERDEFINED"); items.push_back("VANEAXIAL"); - IfcFanTypeEnum_type = new enumeration_type("IfcFanTypeEnum", items); + IfcFanTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcFanTypeEnum, items); } - declaration* IfcFilterTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("AIRPARTICLEFILTER"); @@ -1078,9 +1991,8 @@ void populate() { items.push_back("STRAINER"); items.push_back("USERDEFINED"); items.push_back("WATERFILTER"); - IfcFilterTypeEnum_type = new enumeration_type("IfcFilterTypeEnum", items); + IfcFilterTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcFilterTypeEnum, items); } - declaration* IfcFireSuppressionTerminalTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("BREECHINGINLET"); @@ -1090,18 +2002,16 @@ void populate() { items.push_back("SPRINKLER"); items.push_back("SPRINKLERDEFLECTOR"); items.push_back("USERDEFINED"); - IfcFireSuppressionTerminalTypeEnum_type = new enumeration_type("IfcFireSuppressionTerminalTypeEnum", items); + IfcFireSuppressionTerminalTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcFireSuppressionTerminalTypeEnum, items); } - declaration* IfcFlowDirectionEnum_type; { std::vector items; items.reserve(4); items.push_back("NOTDEFINED"); items.push_back("SINK"); items.push_back("SOURCE"); items.push_back("SOURCEANDSINK"); - IfcFlowDirectionEnum_type = new enumeration_type("IfcFlowDirectionEnum", items); + IfcFlowDirectionEnum_type = new enumeration_type(IfcSchema::Type::IfcFlowDirectionEnum, items); } - declaration* IfcFlowInstrumentTypeEnum_type; { std::vector items; items.reserve(10); items.push_back("AMMETER"); @@ -1114,9 +2024,8 @@ void populate() { items.push_back("USERDEFINED"); items.push_back("VOLTMETER_PEAK"); items.push_back("VOLTMETER_RMS"); - IfcFlowInstrumentTypeEnum_type = new enumeration_type("IfcFlowInstrumentTypeEnum", items); + IfcFlowInstrumentTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcFlowInstrumentTypeEnum, items); } - declaration* IfcFlowMeterTypeEnum_type; { std::vector items; items.reserve(8); items.push_back("ELECTRICMETER"); @@ -1127,9 +2036,8 @@ void populate() { items.push_back("OILMETER"); items.push_back("USERDEFINED"); items.push_back("WATERMETER"); - IfcFlowMeterTypeEnum_type = new enumeration_type("IfcFlowMeterTypeEnum", items); + IfcFlowMeterTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcFlowMeterTypeEnum, items); } - declaration* IfcFootingTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("FOOTING_BEAM"); @@ -1138,9 +2046,8 @@ void populate() { items.push_back("PILE_CAP"); items.push_back("STRIP_FOOTING"); items.push_back("USERDEFINED"); - IfcFootingTypeEnum_type = new enumeration_type("IfcFootingTypeEnum", items); + IfcFootingTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcFootingTypeEnum, items); } - declaration* IfcGasTerminalTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("GASAPPLIANCE"); @@ -1148,9 +2055,8 @@ void populate() { items.push_back("GASBURNER"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcGasTerminalTypeEnum_type = new enumeration_type("IfcGasTerminalTypeEnum", items); + IfcGasTerminalTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcGasTerminalTypeEnum, items); } - declaration* IfcGeometricProjectionEnum_type; { std::vector items; items.reserve(9); items.push_back("ELEVATION_VIEW"); @@ -1162,25 +2068,22 @@ void populate() { items.push_back("SECTION_VIEW"); items.push_back("SKETCH_VIEW"); items.push_back("USERDEFINED"); - IfcGeometricProjectionEnum_type = new enumeration_type("IfcGeometricProjectionEnum", items); + IfcGeometricProjectionEnum_type = new enumeration_type(IfcSchema::Type::IfcGeometricProjectionEnum, items); } - declaration* IfcGlobalOrLocalEnum_type; { std::vector items; items.reserve(2); items.push_back("GLOBAL_COORDS"); items.push_back("LOCAL_COORDS"); - IfcGlobalOrLocalEnum_type = new enumeration_type("IfcGlobalOrLocalEnum", items); + IfcGlobalOrLocalEnum_type = new enumeration_type(IfcSchema::Type::IfcGlobalOrLocalEnum, items); } - declaration* IfcHeatExchangerTypeEnum_type; { std::vector items; items.reserve(4); items.push_back("NOTDEFINED"); items.push_back("PLATE"); items.push_back("SHELLANDTUBE"); items.push_back("USERDEFINED"); - IfcHeatExchangerTypeEnum_type = new enumeration_type("IfcHeatExchangerTypeEnum", items); + IfcHeatExchangerTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcHeatExchangerTypeEnum, items); } - declaration* IfcHumidifierTypeEnum_type; { std::vector items; items.reserve(15); items.push_back("ADIABATICAIRWASHER"); @@ -1198,17 +2101,15 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("STEAMINJECTION"); items.push_back("USERDEFINED"); - IfcHumidifierTypeEnum_type = new enumeration_type("IfcHumidifierTypeEnum", items); + IfcHumidifierTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcHumidifierTypeEnum, items); } - declaration* IfcInternalOrExternalEnum_type; { std::vector items; items.reserve(3); items.push_back("EXTERNAL"); items.push_back("INTERNAL"); items.push_back("NOTDEFINED"); - IfcInternalOrExternalEnum_type = new enumeration_type("IfcInternalOrExternalEnum", items); + IfcInternalOrExternalEnum_type = new enumeration_type(IfcSchema::Type::IfcInternalOrExternalEnum, items); } - declaration* IfcInventoryTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("ASSETINVENTORY"); @@ -1216,16 +2117,14 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("SPACEINVENTORY"); items.push_back("USERDEFINED"); - IfcInventoryTypeEnum_type = new enumeration_type("IfcInventoryTypeEnum", items); + IfcInventoryTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcInventoryTypeEnum, items); } - declaration* IfcJunctionBoxTypeEnum_type; { std::vector items; items.reserve(2); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcJunctionBoxTypeEnum_type = new enumeration_type("IfcJunctionBoxTypeEnum", items); + IfcJunctionBoxTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcJunctionBoxTypeEnum, items); } - declaration* IfcLampTypeEnum_type; { std::vector items; items.reserve(8); items.push_back("COMPACTFLUORESCENT"); @@ -1236,26 +2135,23 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("TUNGSTENFILAMENT"); items.push_back("USERDEFINED"); - IfcLampTypeEnum_type = new enumeration_type("IfcLampTypeEnum", items); + IfcLampTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcLampTypeEnum, items); } - declaration* IfcLayerSetDirectionEnum_type; { std::vector items; items.reserve(3); items.push_back("AXIS1"); items.push_back("AXIS2"); items.push_back("AXIS3"); - IfcLayerSetDirectionEnum_type = new enumeration_type("IfcLayerSetDirectionEnum", items); + IfcLayerSetDirectionEnum_type = new enumeration_type(IfcSchema::Type::IfcLayerSetDirectionEnum, items); } - declaration* IfcLightDistributionCurveEnum_type; { std::vector items; items.reserve(4); items.push_back("NOTDEFINED"); items.push_back("TYPE_A"); items.push_back("TYPE_B"); items.push_back("TYPE_C"); - IfcLightDistributionCurveEnum_type = new enumeration_type("IfcLightDistributionCurveEnum", items); + IfcLightDistributionCurveEnum_type = new enumeration_type(IfcSchema::Type::IfcLightDistributionCurveEnum, items); } - declaration* IfcLightEmissionSourceEnum_type; { std::vector items; items.reserve(11); items.push_back("COMPACTFLUORESCENT"); @@ -1269,18 +2165,16 @@ void populate() { items.push_back("METALHALIDE"); items.push_back("NOTDEFINED"); items.push_back("TUNGSTENFILAMENT"); - IfcLightEmissionSourceEnum_type = new enumeration_type("IfcLightEmissionSourceEnum", items); + IfcLightEmissionSourceEnum_type = new enumeration_type(IfcSchema::Type::IfcLightEmissionSourceEnum, items); } - declaration* IfcLightFixtureTypeEnum_type; { std::vector items; items.reserve(4); items.push_back("DIRECTIONSOURCE"); items.push_back("NOTDEFINED"); items.push_back("POINTSOURCE"); items.push_back("USERDEFINED"); - IfcLightFixtureTypeEnum_type = new enumeration_type("IfcLightFixtureTypeEnum", items); + IfcLightFixtureTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcLightFixtureTypeEnum, items); } - declaration* IfcLoadGroupTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("LOAD_CASE"); @@ -1289,16 +2183,14 @@ void populate() { items.push_back("LOAD_GROUP"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcLoadGroupTypeEnum_type = new enumeration_type("IfcLoadGroupTypeEnum", items); + IfcLoadGroupTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcLoadGroupTypeEnum, items); } - declaration* IfcLogicalOperatorEnum_type; { std::vector items; items.reserve(2); items.push_back("LOGICALAND"); items.push_back("LOGICALOR"); - IfcLogicalOperatorEnum_type = new enumeration_type("IfcLogicalOperatorEnum", items); + IfcLogicalOperatorEnum_type = new enumeration_type(IfcSchema::Type::IfcLogicalOperatorEnum, items); } - declaration* IfcMemberTypeEnum_type; { std::vector items; items.reserve(14); items.push_back("BRACE"); @@ -1315,9 +2207,8 @@ void populate() { items.push_back("STRUT"); items.push_back("STUD"); items.push_back("USERDEFINED"); - IfcMemberTypeEnum_type = new enumeration_type("IfcMemberTypeEnum", items); + IfcMemberTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcMemberTypeEnum, items); } - declaration* IfcMotorConnectionTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("BELTDRIVE"); @@ -1325,15 +2216,13 @@ void populate() { items.push_back("DIRECTDRIVE"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcMotorConnectionTypeEnum_type = new enumeration_type("IfcMotorConnectionTypeEnum", items); + IfcMotorConnectionTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcMotorConnectionTypeEnum, items); } - declaration* IfcNullStyle_type; { std::vector items; items.reserve(1); items.push_back("NULL"); - IfcNullStyle_type = new enumeration_type("IfcNullStyle", items); + IfcNullStyle_type = new enumeration_type(IfcSchema::Type::IfcNullStyle, items); } - declaration* IfcObjectTypeEnum_type; { std::vector items; items.reserve(8); items.push_back("ACTOR"); @@ -1344,9 +2233,8 @@ void populate() { items.push_back("PRODUCT"); items.push_back("PROJECT"); items.push_back("RESOURCE"); - IfcObjectTypeEnum_type = new enumeration_type("IfcObjectTypeEnum", items); + IfcObjectTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcObjectTypeEnum, items); } - declaration* IfcObjectiveEnum_type; { std::vector items; items.reserve(8); items.push_back("CODECOMPLIANCE"); @@ -1357,9 +2245,8 @@ void populate() { items.push_back("SPECIFICATION"); items.push_back("TRIGGERCONDITION"); items.push_back("USERDEFINED"); - IfcObjectiveEnum_type = new enumeration_type("IfcObjectiveEnum", items); + IfcObjectiveEnum_type = new enumeration_type(IfcSchema::Type::IfcObjectiveEnum, items); } - declaration* IfcOccupantTypeEnum_type; { std::vector items; items.reserve(9); items.push_back("ASSIGNEE"); @@ -1371,9 +2258,8 @@ void populate() { items.push_back("OWNER"); items.push_back("TENANT"); items.push_back("USERDEFINED"); - IfcOccupantTypeEnum_type = new enumeration_type("IfcOccupantTypeEnum", items); + IfcOccupantTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcOccupantTypeEnum, items); } - declaration* IfcOutletTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("AUDIOVISUALOUTLET"); @@ -1381,9 +2267,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("POWEROUTLET"); items.push_back("USERDEFINED"); - IfcOutletTypeEnum_type = new enumeration_type("IfcOutletTypeEnum", items); + IfcOutletTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcOutletTypeEnum, items); } - declaration* IfcPermeableCoveringOperationEnum_type; { std::vector items; items.reserve(5); items.push_back("GRILL"); @@ -1391,17 +2276,15 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("SCREEN"); items.push_back("USERDEFINED"); - IfcPermeableCoveringOperationEnum_type = new enumeration_type("IfcPermeableCoveringOperationEnum", items); + IfcPermeableCoveringOperationEnum_type = new enumeration_type(IfcSchema::Type::IfcPermeableCoveringOperationEnum, items); } - declaration* IfcPhysicalOrVirtualEnum_type; { std::vector items; items.reserve(3); items.push_back("NOTDEFINED"); items.push_back("PHYSICAL"); items.push_back("VIRTUAL"); - IfcPhysicalOrVirtualEnum_type = new enumeration_type("IfcPhysicalOrVirtualEnum", items); + IfcPhysicalOrVirtualEnum_type = new enumeration_type(IfcSchema::Type::IfcPhysicalOrVirtualEnum, items); } - declaration* IfcPileConstructionEnum_type; { std::vector items; items.reserve(6); items.push_back("CAST_IN_PLACE"); @@ -1410,9 +2293,8 @@ void populate() { items.push_back("PRECAST_CONCRETE"); items.push_back("PREFAB_STEEL"); items.push_back("USERDEFINED"); - IfcPileConstructionEnum_type = new enumeration_type("IfcPileConstructionEnum", items); + IfcPileConstructionEnum_type = new enumeration_type(IfcSchema::Type::IfcPileConstructionEnum, items); } - declaration* IfcPileTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("COHESION"); @@ -1420,9 +2302,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("SUPPORT"); items.push_back("USERDEFINED"); - IfcPileTypeEnum_type = new enumeration_type("IfcPileTypeEnum", items); + IfcPileTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcPileTypeEnum, items); } - declaration* IfcPipeFittingTypeEnum_type; { std::vector items; items.reserve(9); items.push_back("BEND"); @@ -1434,9 +2315,8 @@ void populate() { items.push_back("OBSTRUCTION"); items.push_back("TRANSITION"); items.push_back("USERDEFINED"); - IfcPipeFittingTypeEnum_type = new enumeration_type("IfcPipeFittingTypeEnum", items); + IfcPipeFittingTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcPipeFittingTypeEnum, items); } - declaration* IfcPipeSegmentTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("FLEXIBLESEGMENT"); @@ -1445,18 +2325,16 @@ void populate() { items.push_back("RIGIDSEGMENT"); items.push_back("SPOOL"); items.push_back("USERDEFINED"); - IfcPipeSegmentTypeEnum_type = new enumeration_type("IfcPipeSegmentTypeEnum", items); + IfcPipeSegmentTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcPipeSegmentTypeEnum, items); } - declaration* IfcPlateTypeEnum_type; { std::vector items; items.reserve(4); items.push_back("CURTAIN_PANEL"); items.push_back("NOTDEFINED"); items.push_back("SHEET"); items.push_back("USERDEFINED"); - IfcPlateTypeEnum_type = new enumeration_type("IfcPlateTypeEnum", items); + IfcPlateTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcPlateTypeEnum, items); } - declaration* IfcProcedureTypeEnum_type; { std::vector items; items.reserve(9); items.push_back("ADVICE_CAUTION"); @@ -1468,16 +2346,14 @@ void populate() { items.push_back("SHUTDOWN"); items.push_back("STARTUP"); items.push_back("USERDEFINED"); - IfcProcedureTypeEnum_type = new enumeration_type("IfcProcedureTypeEnum", items); + IfcProcedureTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcProcedureTypeEnum, items); } - declaration* IfcProfileTypeEnum_type; { std::vector items; items.reserve(2); items.push_back("AREA"); items.push_back("CURVE"); - IfcProfileTypeEnum_type = new enumeration_type("IfcProfileTypeEnum", items); + IfcProfileTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcProfileTypeEnum, items); } - declaration* IfcProjectOrderRecordTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("CHANGE"); @@ -1487,9 +2363,8 @@ void populate() { items.push_back("PURCHASE"); items.push_back("USERDEFINED"); items.push_back("WORK"); - IfcProjectOrderRecordTypeEnum_type = new enumeration_type("IfcProjectOrderRecordTypeEnum", items); + IfcProjectOrderRecordTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcProjectOrderRecordTypeEnum, items); } - declaration* IfcProjectOrderTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("CHANGEORDER"); @@ -1499,16 +2374,14 @@ void populate() { items.push_back("PURCHASEORDER"); items.push_back("USERDEFINED"); items.push_back("WORKORDER"); - IfcProjectOrderTypeEnum_type = new enumeration_type("IfcProjectOrderTypeEnum", items); + IfcProjectOrderTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcProjectOrderTypeEnum, items); } - declaration* IfcProjectedOrTrueLengthEnum_type; { std::vector items; items.reserve(2); items.push_back("PROJECTED_LENGTH"); items.push_back("TRUE_LENGTH"); - IfcProjectedOrTrueLengthEnum_type = new enumeration_type("IfcProjectedOrTrueLengthEnum", items); + IfcProjectedOrTrueLengthEnum_type = new enumeration_type(IfcSchema::Type::IfcProjectedOrTrueLengthEnum, items); } - declaration* IfcPropertySourceEnum_type; { std::vector items; items.reserve(9); items.push_back("ASBUILT"); @@ -1520,9 +2393,8 @@ void populate() { items.push_back("NOTKNOWN"); items.push_back("SIMULATED"); items.push_back("USERDEFINED"); - IfcPropertySourceEnum_type = new enumeration_type("IfcPropertySourceEnum", items); + IfcPropertySourceEnum_type = new enumeration_type(IfcSchema::Type::IfcPropertySourceEnum, items); } - declaration* IfcProtectiveDeviceTypeEnum_type; { std::vector items; items.reserve(8); items.push_back("CIRCUITBREAKER"); @@ -1533,9 +2405,8 @@ void populate() { items.push_back("RESIDUALCURRENTSWITCH"); items.push_back("USERDEFINED"); items.push_back("VARISTOR"); - IfcProtectiveDeviceTypeEnum_type = new enumeration_type("IfcProtectiveDeviceTypeEnum", items); + IfcProtectiveDeviceTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcProtectiveDeviceTypeEnum, items); } - declaration* IfcPumpTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("CIRCULATOR"); @@ -1545,9 +2416,8 @@ void populate() { items.push_back("USERDEFINED"); items.push_back("VERTICALINLINE"); items.push_back("VERTICALTURBINE"); - IfcPumpTypeEnum_type = new enumeration_type("IfcPumpTypeEnum", items); + IfcPumpTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcPumpTypeEnum, items); } - declaration* IfcRailingTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("BALUSTRADE"); @@ -1555,18 +2425,16 @@ void populate() { items.push_back("HANDRAIL"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcRailingTypeEnum_type = new enumeration_type("IfcRailingTypeEnum", items); + IfcRailingTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcRailingTypeEnum, items); } - declaration* IfcRampFlightTypeEnum_type; { std::vector items; items.reserve(4); items.push_back("NOTDEFINED"); items.push_back("SPIRAL"); items.push_back("STRAIGHT"); items.push_back("USERDEFINED"); - IfcRampFlightTypeEnum_type = new enumeration_type("IfcRampFlightTypeEnum", items); + IfcRampFlightTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcRampFlightTypeEnum, items); } - declaration* IfcRampTypeEnum_type; { std::vector items; items.reserve(8); items.push_back("HALF_TURN_RAMP"); @@ -1577,9 +2445,8 @@ void populate() { items.push_back("TWO_QUARTER_TURN_RAMP"); items.push_back("TWO_STRAIGHT_RUN_RAMP"); items.push_back("USERDEFINED"); - IfcRampTypeEnum_type = new enumeration_type("IfcRampTypeEnum", items); + IfcRampTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcRampTypeEnum, items); } - declaration* IfcReflectanceMethodEnum_type; { std::vector items; items.reserve(10); items.push_back("BLINN"); @@ -1592,9 +2459,8 @@ void populate() { items.push_back("PHONG"); items.push_back("PLASTIC"); items.push_back("STRAUSS"); - IfcReflectanceMethodEnum_type = new enumeration_type("IfcReflectanceMethodEnum", items); + IfcReflectanceMethodEnum_type = new enumeration_type(IfcSchema::Type::IfcReflectanceMethodEnum, items); } - declaration* IfcReinforcingBarRoleEnum_type; { std::vector items; items.reserve(9); items.push_back("EDGE"); @@ -1606,16 +2472,14 @@ void populate() { items.push_back("SHEAR"); items.push_back("STUD"); items.push_back("USERDEFINED"); - IfcReinforcingBarRoleEnum_type = new enumeration_type("IfcReinforcingBarRoleEnum", items); + IfcReinforcingBarRoleEnum_type = new enumeration_type(IfcSchema::Type::IfcReinforcingBarRoleEnum, items); } - declaration* IfcReinforcingBarSurfaceEnum_type; { std::vector items; items.reserve(2); items.push_back("PLAIN"); items.push_back("TEXTURED"); - IfcReinforcingBarSurfaceEnum_type = new enumeration_type("IfcReinforcingBarSurfaceEnum", items); + IfcReinforcingBarSurfaceEnum_type = new enumeration_type(IfcSchema::Type::IfcReinforcingBarSurfaceEnum, items); } - declaration* IfcResourceConsumptionEnum_type; { std::vector items; items.reserve(8); items.push_back("CONSUMED"); @@ -1626,16 +2490,14 @@ void populate() { items.push_back("PARTIALLYCONSUMED"); items.push_back("PARTIALLYOCCUPIED"); items.push_back("USERDEFINED"); - IfcResourceConsumptionEnum_type = new enumeration_type("IfcResourceConsumptionEnum", items); + IfcResourceConsumptionEnum_type = new enumeration_type(IfcSchema::Type::IfcResourceConsumptionEnum, items); } - declaration* IfcRibPlateDirectionEnum_type; { std::vector items; items.reserve(2); items.push_back("DIRECTION_X"); items.push_back("DIRECTION_Y"); - IfcRibPlateDirectionEnum_type = new enumeration_type("IfcRibPlateDirectionEnum", items); + IfcRibPlateDirectionEnum_type = new enumeration_type(IfcSchema::Type::IfcRibPlateDirectionEnum, items); } - declaration* IfcRoleEnum_type; { std::vector items; items.reserve(23); items.push_back("ARCHITECT"); @@ -1661,9 +2523,8 @@ void populate() { items.push_back("SUBCONTRACTOR"); items.push_back("SUPPLIER"); items.push_back("USERDEFINED"); - IfcRoleEnum_type = new enumeration_type("IfcRoleEnum", items); + IfcRoleEnum_type = new enumeration_type(IfcSchema::Type::IfcRoleEnum, items); } - declaration* IfcRoofTypeEnum_type; { std::vector items; items.reserve(14); items.push_back("BARREL_ROOF"); @@ -1680,9 +2541,8 @@ void populate() { items.push_back("PAVILION_ROOF"); items.push_back("RAINBOW_ROOF"); items.push_back("SHED_ROOF"); - IfcRoofTypeEnum_type = new enumeration_type("IfcRoofTypeEnum", items); + IfcRoofTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcRoofTypeEnum, items); } - declaration* IfcSIPrefix_type; { std::vector items; items.reserve(16); items.push_back("ATTO"); @@ -1701,9 +2561,8 @@ void populate() { items.push_back("PETA"); items.push_back("PICO"); items.push_back("TERA"); - IfcSIPrefix_type = new enumeration_type("IfcSIPrefix", items); + IfcSIPrefix_type = new enumeration_type(IfcSchema::Type::IfcSIPrefix, items); } - declaration* IfcSIUnitName_type; { std::vector items; items.reserve(30); items.push_back("AMPERE"); @@ -1736,9 +2595,8 @@ void populate() { items.push_back("VOLT"); items.push_back("WATT"); items.push_back("WEBER"); - IfcSIUnitName_type = new enumeration_type("IfcSIUnitName", items); + IfcSIUnitName_type = new enumeration_type(IfcSchema::Type::IfcSIUnitName, items); } - declaration* IfcSanitaryTerminalTypeEnum_type; { std::vector items; items.reserve(12); items.push_back("BATH"); @@ -1753,16 +2611,14 @@ void populate() { items.push_back("USERDEFINED"); items.push_back("WASHHANDBASIN"); items.push_back("WCSEAT"); - IfcSanitaryTerminalTypeEnum_type = new enumeration_type("IfcSanitaryTerminalTypeEnum", items); + IfcSanitaryTerminalTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcSanitaryTerminalTypeEnum, items); } - declaration* IfcSectionTypeEnum_type; { std::vector items; items.reserve(2); items.push_back("TAPERED"); items.push_back("UNIFORM"); - IfcSectionTypeEnum_type = new enumeration_type("IfcSectionTypeEnum", items); + IfcSectionTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcSectionTypeEnum, items); } - declaration* IfcSensorTypeEnum_type; { std::vector items; items.reserve(15); items.push_back("CO2SENSOR"); @@ -1780,9 +2636,8 @@ void populate() { items.push_back("SOUNDSENSOR"); items.push_back("TEMPERATURESENSOR"); items.push_back("USERDEFINED"); - IfcSensorTypeEnum_type = new enumeration_type("IfcSensorTypeEnum", items); + IfcSensorTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcSensorTypeEnum, items); } - declaration* IfcSequenceEnum_type; { std::vector items; items.reserve(5); items.push_back("FINISH_FINISH"); @@ -1790,9 +2645,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("START_FINISH"); items.push_back("START_START"); - IfcSequenceEnum_type = new enumeration_type("IfcSequenceEnum", items); + IfcSequenceEnum_type = new enumeration_type(IfcSchema::Type::IfcSequenceEnum, items); } - declaration* IfcServiceLifeFactorTypeEnum_type; { std::vector items; items.reserve(9); items.push_back("A_QUALITYOFCOMPONENTS"); @@ -1804,9 +2658,8 @@ void populate() { items.push_back("G_MAINTENANCELEVEL"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcServiceLifeFactorTypeEnum_type = new enumeration_type("IfcServiceLifeFactorTypeEnum", items); + IfcServiceLifeFactorTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcServiceLifeFactorTypeEnum, items); } - declaration* IfcServiceLifeTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("ACTUALSERVICELIFE"); @@ -1814,9 +2667,8 @@ void populate() { items.push_back("OPTIMISTICREFERENCESERVICELIFE"); items.push_back("PESSIMISTICREFERENCESERVICELIFE"); items.push_back("REFERENCESERVICELIFE"); - IfcServiceLifeTypeEnum_type = new enumeration_type("IfcServiceLifeTypeEnum", items); + IfcServiceLifeTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcServiceLifeTypeEnum, items); } - declaration* IfcSlabTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("BASESLAB"); @@ -1825,9 +2677,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("ROOF"); items.push_back("USERDEFINED"); - IfcSlabTypeEnum_type = new enumeration_type("IfcSlabTypeEnum", items); + IfcSlabTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcSlabTypeEnum, items); } - declaration* IfcSoundScaleEnum_type; { std::vector items; items.reserve(7); items.push_back("DBA"); @@ -1837,9 +2688,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("NR"); items.push_back("USERDEFINED"); - IfcSoundScaleEnum_type = new enumeration_type("IfcSoundScaleEnum", items); + IfcSoundScaleEnum_type = new enumeration_type(IfcSchema::Type::IfcSoundScaleEnum, items); } - declaration* IfcSpaceHeaterTypeEnum_type; { std::vector items; items.reserve(9); items.push_back("BASEBOARDHEATER"); @@ -1851,16 +2701,14 @@ void populate() { items.push_back("TUBULARRADIATOR"); items.push_back("UNITHEATER"); items.push_back("USERDEFINED"); - IfcSpaceHeaterTypeEnum_type = new enumeration_type("IfcSpaceHeaterTypeEnum", items); + IfcSpaceHeaterTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcSpaceHeaterTypeEnum, items); } - declaration* IfcSpaceTypeEnum_type; { std::vector items; items.reserve(2); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcSpaceTypeEnum_type = new enumeration_type("IfcSpaceTypeEnum", items); + IfcSpaceTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcSpaceTypeEnum, items); } - declaration* IfcStackTerminalTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("BIRDCAGE"); @@ -1868,9 +2716,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("RAINWATERHOPPER"); items.push_back("USERDEFINED"); - IfcStackTerminalTypeEnum_type = new enumeration_type("IfcStackTerminalTypeEnum", items); + IfcStackTerminalTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcStackTerminalTypeEnum, items); } - declaration* IfcStairFlightTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("CURVED"); @@ -1880,9 +2727,8 @@ void populate() { items.push_back("STRAIGHT"); items.push_back("USERDEFINED"); items.push_back("WINDER"); - IfcStairFlightTypeEnum_type = new enumeration_type("IfcStairFlightTypeEnum", items); + IfcStairFlightTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcStairFlightTypeEnum, items); } - declaration* IfcStairTypeEnum_type; { std::vector items; items.reserve(16); items.push_back("CURVED_RUN_STAIR"); @@ -1901,9 +2747,8 @@ void populate() { items.push_back("TWO_QUARTER_WINDING_STAIR"); items.push_back("TWO_STRAIGHT_RUN_STAIR"); items.push_back("USERDEFINED"); - IfcStairTypeEnum_type = new enumeration_type("IfcStairTypeEnum", items); + IfcStairTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcStairTypeEnum, items); } - declaration* IfcStateEnum_type; { std::vector items; items.reserve(5); items.push_back("LOCKED"); @@ -1911,9 +2756,8 @@ void populate() { items.push_back("READONLYLOCKED"); items.push_back("READWRITE"); items.push_back("READWRITELOCKED"); - IfcStateEnum_type = new enumeration_type("IfcStateEnum", items); + IfcStateEnum_type = new enumeration_type(IfcSchema::Type::IfcStateEnum, items); } - declaration* IfcStructuralCurveTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("CABLE"); @@ -1923,9 +2767,8 @@ void populate() { items.push_back("RIGID_JOINED_MEMBER"); items.push_back("TENSION_MEMBER"); items.push_back("USERDEFINED"); - IfcStructuralCurveTypeEnum_type = new enumeration_type("IfcStructuralCurveTypeEnum", items); + IfcStructuralCurveTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcStructuralCurveTypeEnum, items); } - declaration* IfcStructuralSurfaceTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("BENDING_ELEMENT"); @@ -1933,17 +2776,15 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("SHELL"); items.push_back("USERDEFINED"); - IfcStructuralSurfaceTypeEnum_type = new enumeration_type("IfcStructuralSurfaceTypeEnum", items); + IfcStructuralSurfaceTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcStructuralSurfaceTypeEnum, items); } - declaration* IfcSurfaceSide_type; { std::vector items; items.reserve(3); items.push_back("BOTH"); items.push_back("NEGATIVE"); items.push_back("POSITIVE"); - IfcSurfaceSide_type = new enumeration_type("IfcSurfaceSide", items); + IfcSurfaceSide_type = new enumeration_type(IfcSchema::Type::IfcSurfaceSide, items); } - declaration* IfcSurfaceTextureEnum_type; { std::vector items; items.reserve(9); items.push_back("BUMP"); @@ -1955,9 +2796,8 @@ void populate() { items.push_back("SPECULAR"); items.push_back("TEXTURE"); items.push_back("TRANSPARENCYMAP"); - IfcSurfaceTextureEnum_type = new enumeration_type("IfcSurfaceTextureEnum", items); + IfcSurfaceTextureEnum_type = new enumeration_type(IfcSchema::Type::IfcSurfaceTextureEnum, items); } - declaration* IfcSwitchingDeviceTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("CONTACTOR"); @@ -1967,9 +2807,8 @@ void populate() { items.push_back("SWITCHDISCONNECTOR"); items.push_back("TOGGLESWITCH"); items.push_back("USERDEFINED"); - IfcSwitchingDeviceTypeEnum_type = new enumeration_type("IfcSwitchingDeviceTypeEnum", items); + IfcSwitchingDeviceTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcSwitchingDeviceTypeEnum, items); } - declaration* IfcTankTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("EXPANSION"); @@ -1978,9 +2817,8 @@ void populate() { items.push_back("PRESSUREVESSEL"); items.push_back("SECTIONAL"); items.push_back("USERDEFINED"); - IfcTankTypeEnum_type = new enumeration_type("IfcTankTypeEnum", items); + IfcTankTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcTankTypeEnum, items); } - declaration* IfcTendonTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("BAR"); @@ -1989,18 +2827,16 @@ void populate() { items.push_back("STRAND"); items.push_back("USERDEFINED"); items.push_back("WIRE"); - IfcTendonTypeEnum_type = new enumeration_type("IfcTendonTypeEnum", items); + IfcTendonTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcTendonTypeEnum, items); } - declaration* IfcTextPath_type; { std::vector items; items.reserve(4); items.push_back("DOWN"); items.push_back("LEFT"); items.push_back("RIGHT"); items.push_back("UP"); - IfcTextPath_type = new enumeration_type("IfcTextPath", items); + IfcTextPath_type = new enumeration_type(IfcSchema::Type::IfcTextPath, items); } - declaration* IfcThermalLoadSourceEnum_type; { std::vector items; items.reserve(13); items.push_back("AIREXCHANGERATE"); @@ -2016,18 +2852,16 @@ void populate() { items.push_back("USERDEFINED"); items.push_back("VENTILATIONINDOORAIR"); items.push_back("VENTILATIONOUTSIDEAIR"); - IfcThermalLoadSourceEnum_type = new enumeration_type("IfcThermalLoadSourceEnum", items); + IfcThermalLoadSourceEnum_type = new enumeration_type(IfcSchema::Type::IfcThermalLoadSourceEnum, items); } - declaration* IfcThermalLoadTypeEnum_type; { std::vector items; items.reserve(4); items.push_back("LATENT"); items.push_back("NOTDEFINED"); items.push_back("RADIANT"); items.push_back("SENSIBLE"); - IfcThermalLoadTypeEnum_type = new enumeration_type("IfcThermalLoadTypeEnum", items); + IfcThermalLoadTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcThermalLoadTypeEnum, items); } - declaration* IfcTimeSeriesDataTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("CONTINUOUS"); @@ -2037,9 +2871,8 @@ void populate() { items.push_back("PIECEWISEBINARY"); items.push_back("PIECEWISECONSTANT"); items.push_back("PIECEWISECONTINUOUS"); - IfcTimeSeriesDataTypeEnum_type = new enumeration_type("IfcTimeSeriesDataTypeEnum", items); + IfcTimeSeriesDataTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcTimeSeriesDataTypeEnum, items); } - declaration* IfcTimeSeriesScheduleTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("ANNUAL"); @@ -2048,9 +2881,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); items.push_back("WEEKLY"); - IfcTimeSeriesScheduleTypeEnum_type = new enumeration_type("IfcTimeSeriesScheduleTypeEnum", items); + IfcTimeSeriesScheduleTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcTimeSeriesScheduleTypeEnum, items); } - declaration* IfcTransformerTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("CURRENT"); @@ -2058,18 +2890,16 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); items.push_back("VOLTAGE"); - IfcTransformerTypeEnum_type = new enumeration_type("IfcTransformerTypeEnum", items); + IfcTransformerTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcTransformerTypeEnum, items); } - declaration* IfcTransitionCode_type; { std::vector items; items.reserve(4); items.push_back("CONTINUOUS"); items.push_back("CONTSAMEGRADIENT"); items.push_back("CONTSAMEGRADIENTSAMECURVATURE"); items.push_back("DISCONTINUOUS"); - IfcTransitionCode_type = new enumeration_type("IfcTransitionCode", items); + IfcTransitionCode_type = new enumeration_type(IfcSchema::Type::IfcTransitionCode, items); } - declaration* IfcTransportElementTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("ELEVATOR"); @@ -2077,25 +2907,22 @@ void populate() { items.push_back("MOVINGWALKWAY"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcTransportElementTypeEnum_type = new enumeration_type("IfcTransportElementTypeEnum", items); + IfcTransportElementTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcTransportElementTypeEnum, items); } - declaration* IfcTrimmingPreference_type; { std::vector items; items.reserve(3); items.push_back("CARTESIAN"); items.push_back("PARAMETER"); items.push_back("UNSPECIFIED"); - IfcTrimmingPreference_type = new enumeration_type("IfcTrimmingPreference", items); + IfcTrimmingPreference_type = new enumeration_type(IfcSchema::Type::IfcTrimmingPreference, items); } - declaration* IfcTubeBundleTypeEnum_type; { std::vector items; items.reserve(3); items.push_back("FINNED"); items.push_back("NOTDEFINED"); items.push_back("USERDEFINED"); - IfcTubeBundleTypeEnum_type = new enumeration_type("IfcTubeBundleTypeEnum", items); + IfcTubeBundleTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcTubeBundleTypeEnum, items); } - declaration* IfcUnitEnum_type; { std::vector items; items.reserve(30); items.push_back("ABSORBEDDOSEUNIT"); @@ -2128,9 +2955,8 @@ void populate() { items.push_back("TIMEUNIT"); items.push_back("USERDEFINED"); items.push_back("VOLUMEUNIT"); - IfcUnitEnum_type = new enumeration_type("IfcUnitEnum", items); + IfcUnitEnum_type = new enumeration_type(IfcSchema::Type::IfcUnitEnum, items); } - declaration* IfcUnitaryEquipmentTypeEnum_type; { std::vector items; items.reserve(6); items.push_back("AIRCONDITIONINGUNIT"); @@ -2139,9 +2965,8 @@ void populate() { items.push_back("ROOFTOPUNIT"); items.push_back("SPLITSYSTEM"); items.push_back("USERDEFINED"); - IfcUnitaryEquipmentTypeEnum_type = new enumeration_type("IfcUnitaryEquipmentTypeEnum", items); + IfcUnitaryEquipmentTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcUnitaryEquipmentTypeEnum, items); } - declaration* IfcValveTypeEnum_type; { std::vector items; items.reserve(23); items.push_back("AIRRELEASE"); @@ -2167,18 +2992,16 @@ void populate() { items.push_back("STEAMTRAP"); items.push_back("STOPCOCK"); items.push_back("USERDEFINED"); - IfcValveTypeEnum_type = new enumeration_type("IfcValveTypeEnum", items); + IfcValveTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcValveTypeEnum, items); } - declaration* IfcVibrationIsolatorTypeEnum_type; { std::vector items; items.reserve(4); items.push_back("COMPRESSION"); items.push_back("NOTDEFINED"); items.push_back("SPRING"); items.push_back("USERDEFINED"); - IfcVibrationIsolatorTypeEnum_type = new enumeration_type("IfcVibrationIsolatorTypeEnum", items); + IfcVibrationIsolatorTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcVibrationIsolatorTypeEnum, items); } - declaration* IfcWallTypeEnum_type; { std::vector items; items.reserve(7); items.push_back("ELEMENTEDWALL"); @@ -2188,9 +3011,8 @@ void populate() { items.push_back("SHEAR"); items.push_back("STANDARD"); items.push_back("USERDEFINED"); - IfcWallTypeEnum_type = new enumeration_type("IfcWallTypeEnum", items); + IfcWallTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcWallTypeEnum, items); } - declaration* IfcWasteTerminalTypeEnum_type; { std::vector items; items.reserve(12); items.push_back("FLOORTRAP"); @@ -2205,9 +3027,8 @@ void populate() { items.push_back("USERDEFINED"); items.push_back("WASTEDISPOSALUNIT"); items.push_back("WASTETRAP"); - IfcWasteTerminalTypeEnum_type = new enumeration_type("IfcWasteTerminalTypeEnum", items); + IfcWasteTerminalTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcWasteTerminalTypeEnum, items); } - declaration* IfcWindowPanelOperationEnum_type; { std::vector items; items.reserve(14); items.push_back("BOTTOMHUNG"); @@ -2224,9 +3045,8 @@ void populate() { items.push_back("TILTANDTURNLEFTHAND"); items.push_back("TILTANDTURNRIGHTHAND"); items.push_back("TOPHUNG"); - IfcWindowPanelOperationEnum_type = new enumeration_type("IfcWindowPanelOperationEnum", items); + IfcWindowPanelOperationEnum_type = new enumeration_type(IfcSchema::Type::IfcWindowPanelOperationEnum, items); } - declaration* IfcWindowPanelPositionEnum_type; { std::vector items; items.reserve(6); items.push_back("BOTTOM"); @@ -2235,9 +3055,8 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("RIGHT"); items.push_back("TOP"); - IfcWindowPanelPositionEnum_type = new enumeration_type("IfcWindowPanelPositionEnum", items); + IfcWindowPanelPositionEnum_type = new enumeration_type(IfcSchema::Type::IfcWindowPanelPositionEnum, items); } - declaration* IfcWindowStyleConstructionEnum_type; { std::vector items; items.reserve(8); items.push_back("ALUMINIUM"); @@ -2248,9 +3067,8 @@ void populate() { items.push_back("PLASTIC"); items.push_back("STEEL"); items.push_back("WOOD"); - IfcWindowStyleConstructionEnum_type = new enumeration_type("IfcWindowStyleConstructionEnum", items); + IfcWindowStyleConstructionEnum_type = new enumeration_type(IfcSchema::Type::IfcWindowStyleConstructionEnum, items); } - declaration* IfcWindowStyleOperationEnum_type; { std::vector items; items.reserve(11); items.push_back("DOUBLE_PANEL_HORIZONTAL"); @@ -2264,9 +3082,8 @@ void populate() { items.push_back("TRIPLE_PANEL_TOP"); items.push_back("TRIPLE_PANEL_VERTICAL"); items.push_back("USERDEFINED"); - IfcWindowStyleOperationEnum_type = new enumeration_type("IfcWindowStyleOperationEnum", items); + IfcWindowStyleOperationEnum_type = new enumeration_type(IfcSchema::Type::IfcWindowStyleOperationEnum, items); } - declaration* IfcWorkControlTypeEnum_type; { std::vector items; items.reserve(5); items.push_back("ACTUAL"); @@ -2274,764 +3091,749 @@ void populate() { items.push_back("NOTDEFINED"); items.push_back("PLANNED"); items.push_back("USERDEFINED"); - IfcWorkControlTypeEnum_type = new enumeration_type("IfcWorkControlTypeEnum", items); + IfcWorkControlTypeEnum_type = new enumeration_type(IfcSchema::Type::IfcWorkControlTypeEnum, items); } - entity* IfcActorRole_type = new entity("IfcActorRole", 0); - entity* IfcAddress_type = new entity("IfcAddress", 0); - entity* IfcApplication_type = new entity("IfcApplication", 0); - entity* IfcAppliedValue_type = new entity("IfcAppliedValue", 0); - entity* IfcAppliedValueRelationship_type = new entity("IfcAppliedValueRelationship", 0); - entity* IfcApproval_type = new entity("IfcApproval", 0); - entity* IfcApprovalActorRelationship_type = new entity("IfcApprovalActorRelationship", 0); - entity* IfcApprovalPropertyRelationship_type = new entity("IfcApprovalPropertyRelationship", 0); - entity* IfcApprovalRelationship_type = new entity("IfcApprovalRelationship", 0); - entity* IfcBoundaryCondition_type = new entity("IfcBoundaryCondition", 0); - entity* IfcBoundaryEdgeCondition_type = new entity("IfcBoundaryEdgeCondition", IfcBoundaryCondition_type); - entity* IfcBoundaryFaceCondition_type = new entity("IfcBoundaryFaceCondition", IfcBoundaryCondition_type); - entity* IfcBoundaryNodeCondition_type = new entity("IfcBoundaryNodeCondition", IfcBoundaryCondition_type); - entity* IfcBoundaryNodeConditionWarping_type = new entity("IfcBoundaryNodeConditionWarping", IfcBoundaryNodeCondition_type); - entity* IfcCalendarDate_type = new entity("IfcCalendarDate", 0); - entity* IfcClassification_type = new entity("IfcClassification", 0); - entity* IfcClassificationItem_type = new entity("IfcClassificationItem", 0); - entity* IfcClassificationItemRelationship_type = new entity("IfcClassificationItemRelationship", 0); - entity* IfcClassificationNotation_type = new entity("IfcClassificationNotation", 0); - entity* IfcClassificationNotationFacet_type = new entity("IfcClassificationNotationFacet", 0); - entity* IfcColourSpecification_type = new entity("IfcColourSpecification", 0); - entity* IfcConnectionGeometry_type = new entity("IfcConnectionGeometry", 0); - entity* IfcConnectionPointGeometry_type = new entity("IfcConnectionPointGeometry", IfcConnectionGeometry_type); - entity* IfcConnectionPortGeometry_type = new entity("IfcConnectionPortGeometry", IfcConnectionGeometry_type); - entity* IfcConnectionSurfaceGeometry_type = new entity("IfcConnectionSurfaceGeometry", IfcConnectionGeometry_type); - entity* IfcConstraint_type = new entity("IfcConstraint", 0); - entity* IfcConstraintAggregationRelationship_type = new entity("IfcConstraintAggregationRelationship", 0); - entity* IfcConstraintClassificationRelationship_type = new entity("IfcConstraintClassificationRelationship", 0); - entity* IfcConstraintRelationship_type = new entity("IfcConstraintRelationship", 0); - entity* IfcCoordinatedUniversalTimeOffset_type = new entity("IfcCoordinatedUniversalTimeOffset", 0); - entity* IfcCostValue_type = new entity("IfcCostValue", IfcAppliedValue_type); - entity* IfcCurrencyRelationship_type = new entity("IfcCurrencyRelationship", 0); - entity* IfcCurveStyleFont_type = new entity("IfcCurveStyleFont", 0); - entity* IfcCurveStyleFontAndScaling_type = new entity("IfcCurveStyleFontAndScaling", 0); - entity* IfcCurveStyleFontPattern_type = new entity("IfcCurveStyleFontPattern", 0); - entity* IfcDateAndTime_type = new entity("IfcDateAndTime", 0); - entity* IfcDerivedUnit_type = new entity("IfcDerivedUnit", 0); - entity* IfcDerivedUnitElement_type = new entity("IfcDerivedUnitElement", 0); - entity* IfcDimensionalExponents_type = new entity("IfcDimensionalExponents", 0); - entity* IfcDocumentElectronicFormat_type = new entity("IfcDocumentElectronicFormat", 0); - entity* IfcDocumentInformation_type = new entity("IfcDocumentInformation", 0); - entity* IfcDocumentInformationRelationship_type = new entity("IfcDocumentInformationRelationship", 0); - entity* IfcDraughtingCalloutRelationship_type = new entity("IfcDraughtingCalloutRelationship", 0); - entity* IfcEnvironmentalImpactValue_type = new entity("IfcEnvironmentalImpactValue", IfcAppliedValue_type); - entity* IfcExternalReference_type = new entity("IfcExternalReference", 0); - entity* IfcExternallyDefinedHatchStyle_type = new entity("IfcExternallyDefinedHatchStyle", IfcExternalReference_type); - entity* IfcExternallyDefinedSurfaceStyle_type = new entity("IfcExternallyDefinedSurfaceStyle", IfcExternalReference_type); - entity* IfcExternallyDefinedSymbol_type = new entity("IfcExternallyDefinedSymbol", IfcExternalReference_type); - entity* IfcExternallyDefinedTextFont_type = new entity("IfcExternallyDefinedTextFont", IfcExternalReference_type); - entity* IfcGridAxis_type = new entity("IfcGridAxis", 0); - entity* IfcIrregularTimeSeriesValue_type = new entity("IfcIrregularTimeSeriesValue", 0); - entity* IfcLibraryInformation_type = new entity("IfcLibraryInformation", 0); - entity* IfcLibraryReference_type = new entity("IfcLibraryReference", IfcExternalReference_type); - entity* IfcLightDistributionData_type = new entity("IfcLightDistributionData", 0); - entity* IfcLightIntensityDistribution_type = new entity("IfcLightIntensityDistribution", 0); - entity* IfcLocalTime_type = new entity("IfcLocalTime", 0); - entity* IfcMaterial_type = new entity("IfcMaterial", 0); - entity* IfcMaterialClassificationRelationship_type = new entity("IfcMaterialClassificationRelationship", 0); - entity* IfcMaterialLayer_type = new entity("IfcMaterialLayer", 0); - entity* IfcMaterialLayerSet_type = new entity("IfcMaterialLayerSet", 0); - entity* IfcMaterialLayerSetUsage_type = new entity("IfcMaterialLayerSetUsage", 0); - entity* IfcMaterialList_type = new entity("IfcMaterialList", 0); - entity* IfcMaterialProperties_type = new entity("IfcMaterialProperties", 0); - entity* IfcMeasureWithUnit_type = new entity("IfcMeasureWithUnit", 0); - entity* IfcMechanicalMaterialProperties_type = new entity("IfcMechanicalMaterialProperties", IfcMaterialProperties_type); - entity* IfcMechanicalSteelMaterialProperties_type = new entity("IfcMechanicalSteelMaterialProperties", IfcMechanicalMaterialProperties_type); - entity* IfcMetric_type = new entity("IfcMetric", IfcConstraint_type); - entity* IfcMonetaryUnit_type = new entity("IfcMonetaryUnit", 0); - entity* IfcNamedUnit_type = new entity("IfcNamedUnit", 0); - entity* IfcObjectPlacement_type = new entity("IfcObjectPlacement", 0); - entity* IfcObjective_type = new entity("IfcObjective", IfcConstraint_type); - entity* IfcOpticalMaterialProperties_type = new entity("IfcOpticalMaterialProperties", IfcMaterialProperties_type); - entity* IfcOrganization_type = new entity("IfcOrganization", 0); - entity* IfcOrganizationRelationship_type = new entity("IfcOrganizationRelationship", 0); - entity* IfcOwnerHistory_type = new entity("IfcOwnerHistory", 0); - entity* IfcPerson_type = new entity("IfcPerson", 0); - entity* IfcPersonAndOrganization_type = new entity("IfcPersonAndOrganization", 0); - entity* IfcPhysicalQuantity_type = new entity("IfcPhysicalQuantity", 0); - entity* IfcPhysicalSimpleQuantity_type = new entity("IfcPhysicalSimpleQuantity", IfcPhysicalQuantity_type); - entity* IfcPostalAddress_type = new entity("IfcPostalAddress", IfcAddress_type); - entity* IfcPreDefinedItem_type = new entity("IfcPreDefinedItem", 0); - entity* IfcPreDefinedSymbol_type = new entity("IfcPreDefinedSymbol", IfcPreDefinedItem_type); - entity* IfcPreDefinedTerminatorSymbol_type = new entity("IfcPreDefinedTerminatorSymbol", IfcPreDefinedSymbol_type); - entity* IfcPreDefinedTextFont_type = new entity("IfcPreDefinedTextFont", IfcPreDefinedItem_type); - entity* IfcPresentationLayerAssignment_type = new entity("IfcPresentationLayerAssignment", 0); - entity* IfcPresentationLayerWithStyle_type = new entity("IfcPresentationLayerWithStyle", IfcPresentationLayerAssignment_type); - entity* IfcPresentationStyle_type = new entity("IfcPresentationStyle", 0); - entity* IfcPresentationStyleAssignment_type = new entity("IfcPresentationStyleAssignment", 0); - entity* IfcProductRepresentation_type = new entity("IfcProductRepresentation", 0); - entity* IfcProductsOfCombustionProperties_type = new entity("IfcProductsOfCombustionProperties", IfcMaterialProperties_type); - entity* IfcProfileDef_type = new entity("IfcProfileDef", 0); - entity* IfcProfileProperties_type = new entity("IfcProfileProperties", 0); - entity* IfcProperty_type = new entity("IfcProperty", 0); - entity* IfcPropertyConstraintRelationship_type = new entity("IfcPropertyConstraintRelationship", 0); - entity* IfcPropertyDependencyRelationship_type = new entity("IfcPropertyDependencyRelationship", 0); - entity* IfcPropertyEnumeration_type = new entity("IfcPropertyEnumeration", 0); - entity* IfcQuantityArea_type = new entity("IfcQuantityArea", IfcPhysicalSimpleQuantity_type); - entity* IfcQuantityCount_type = new entity("IfcQuantityCount", IfcPhysicalSimpleQuantity_type); - entity* IfcQuantityLength_type = new entity("IfcQuantityLength", IfcPhysicalSimpleQuantity_type); - entity* IfcQuantityTime_type = new entity("IfcQuantityTime", IfcPhysicalSimpleQuantity_type); - entity* IfcQuantityVolume_type = new entity("IfcQuantityVolume", IfcPhysicalSimpleQuantity_type); - entity* IfcQuantityWeight_type = new entity("IfcQuantityWeight", IfcPhysicalSimpleQuantity_type); - entity* IfcReferencesValueDocument_type = new entity("IfcReferencesValueDocument", 0); - entity* IfcReinforcementBarProperties_type = new entity("IfcReinforcementBarProperties", 0); - entity* IfcRelaxation_type = new entity("IfcRelaxation", 0); - entity* IfcRepresentation_type = new entity("IfcRepresentation", 0); - entity* IfcRepresentationContext_type = new entity("IfcRepresentationContext", 0); - entity* IfcRepresentationItem_type = new entity("IfcRepresentationItem", 0); - entity* IfcRepresentationMap_type = new entity("IfcRepresentationMap", 0); - entity* IfcRibPlateProfileProperties_type = new entity("IfcRibPlateProfileProperties", IfcProfileProperties_type); - entity* IfcRoot_type = new entity("IfcRoot", 0); - entity* IfcSIUnit_type = new entity("IfcSIUnit", IfcNamedUnit_type); - entity* IfcSectionProperties_type = new entity("IfcSectionProperties", 0); - entity* IfcSectionReinforcementProperties_type = new entity("IfcSectionReinforcementProperties", 0); - entity* IfcShapeAspect_type = new entity("IfcShapeAspect", 0); - entity* IfcShapeModel_type = new entity("IfcShapeModel", IfcRepresentation_type); - entity* IfcShapeRepresentation_type = new entity("IfcShapeRepresentation", IfcShapeModel_type); - entity* IfcSimpleProperty_type = new entity("IfcSimpleProperty", IfcProperty_type); - entity* IfcStructuralConnectionCondition_type = new entity("IfcStructuralConnectionCondition", 0); - entity* IfcStructuralLoad_type = new entity("IfcStructuralLoad", 0); - entity* IfcStructuralLoadStatic_type = new entity("IfcStructuralLoadStatic", IfcStructuralLoad_type); - entity* IfcStructuralLoadTemperature_type = new entity("IfcStructuralLoadTemperature", IfcStructuralLoadStatic_type); - entity* IfcStyleModel_type = new entity("IfcStyleModel", IfcRepresentation_type); - entity* IfcStyledItem_type = new entity("IfcStyledItem", IfcRepresentationItem_type); - entity* IfcStyledRepresentation_type = new entity("IfcStyledRepresentation", IfcStyleModel_type); - entity* IfcSurfaceStyle_type = new entity("IfcSurfaceStyle", IfcPresentationStyle_type); - entity* IfcSurfaceStyleLighting_type = new entity("IfcSurfaceStyleLighting", 0); - entity* IfcSurfaceStyleRefraction_type = new entity("IfcSurfaceStyleRefraction", 0); - entity* IfcSurfaceStyleShading_type = new entity("IfcSurfaceStyleShading", 0); - entity* IfcSurfaceStyleWithTextures_type = new entity("IfcSurfaceStyleWithTextures", 0); - entity* IfcSurfaceTexture_type = new entity("IfcSurfaceTexture", 0); - entity* IfcSymbolStyle_type = new entity("IfcSymbolStyle", IfcPresentationStyle_type); - entity* IfcTable_type = new entity("IfcTable", 0); - entity* IfcTableRow_type = new entity("IfcTableRow", 0); - entity* IfcTelecomAddress_type = new entity("IfcTelecomAddress", IfcAddress_type); - entity* IfcTextStyle_type = new entity("IfcTextStyle", IfcPresentationStyle_type); - entity* IfcTextStyleFontModel_type = new entity("IfcTextStyleFontModel", IfcPreDefinedTextFont_type); - entity* IfcTextStyleForDefinedFont_type = new entity("IfcTextStyleForDefinedFont", 0); - entity* IfcTextStyleTextModel_type = new entity("IfcTextStyleTextModel", 0); - entity* IfcTextStyleWithBoxCharacteristics_type = new entity("IfcTextStyleWithBoxCharacteristics", 0); - entity* IfcTextureCoordinate_type = new entity("IfcTextureCoordinate", 0); - entity* IfcTextureCoordinateGenerator_type = new entity("IfcTextureCoordinateGenerator", IfcTextureCoordinate_type); - entity* IfcTextureMap_type = new entity("IfcTextureMap", IfcTextureCoordinate_type); - entity* IfcTextureVertex_type = new entity("IfcTextureVertex", 0); - entity* IfcThermalMaterialProperties_type = new entity("IfcThermalMaterialProperties", IfcMaterialProperties_type); - entity* IfcTimeSeries_type = new entity("IfcTimeSeries", 0); - entity* IfcTimeSeriesReferenceRelationship_type = new entity("IfcTimeSeriesReferenceRelationship", 0); - entity* IfcTimeSeriesValue_type = new entity("IfcTimeSeriesValue", 0); - entity* IfcTopologicalRepresentationItem_type = new entity("IfcTopologicalRepresentationItem", IfcRepresentationItem_type); - entity* IfcTopologyRepresentation_type = new entity("IfcTopologyRepresentation", IfcShapeModel_type); - entity* IfcUnitAssignment_type = new entity("IfcUnitAssignment", 0); - entity* IfcVertex_type = new entity("IfcVertex", IfcTopologicalRepresentationItem_type); - entity* IfcVertexBasedTextureMap_type = new entity("IfcVertexBasedTextureMap", 0); - entity* IfcVertexPoint_type = new entity("IfcVertexPoint", IfcVertex_type); - entity* IfcVirtualGridIntersection_type = new entity("IfcVirtualGridIntersection", 0); - entity* IfcWaterProperties_type = new entity("IfcWaterProperties", IfcMaterialProperties_type); - entity* IfcAnnotationOccurrence_type = new entity("IfcAnnotationOccurrence", IfcStyledItem_type); - entity* IfcAnnotationSurfaceOccurrence_type = new entity("IfcAnnotationSurfaceOccurrence", IfcAnnotationOccurrence_type); - entity* IfcAnnotationSymbolOccurrence_type = new entity("IfcAnnotationSymbolOccurrence", IfcAnnotationOccurrence_type); - entity* IfcAnnotationTextOccurrence_type = new entity("IfcAnnotationTextOccurrence", IfcAnnotationOccurrence_type); - entity* IfcArbitraryClosedProfileDef_type = new entity("IfcArbitraryClosedProfileDef", IfcProfileDef_type); - entity* IfcArbitraryOpenProfileDef_type = new entity("IfcArbitraryOpenProfileDef", IfcProfileDef_type); - entity* IfcArbitraryProfileDefWithVoids_type = new entity("IfcArbitraryProfileDefWithVoids", IfcArbitraryClosedProfileDef_type); - entity* IfcBlobTexture_type = new entity("IfcBlobTexture", IfcSurfaceTexture_type); - entity* IfcCenterLineProfileDef_type = new entity("IfcCenterLineProfileDef", IfcArbitraryOpenProfileDef_type); - entity* IfcClassificationReference_type = new entity("IfcClassificationReference", IfcExternalReference_type); - entity* IfcColourRgb_type = new entity("IfcColourRgb", IfcColourSpecification_type); - entity* IfcComplexProperty_type = new entity("IfcComplexProperty", IfcProperty_type); - entity* IfcCompositeProfileDef_type = new entity("IfcCompositeProfileDef", IfcProfileDef_type); - entity* IfcConnectedFaceSet_type = new entity("IfcConnectedFaceSet", IfcTopologicalRepresentationItem_type); - entity* IfcConnectionCurveGeometry_type = new entity("IfcConnectionCurveGeometry", IfcConnectionGeometry_type); - entity* IfcConnectionPointEccentricity_type = new entity("IfcConnectionPointEccentricity", IfcConnectionPointGeometry_type); - entity* IfcContextDependentUnit_type = new entity("IfcContextDependentUnit", IfcNamedUnit_type); - entity* IfcConversionBasedUnit_type = new entity("IfcConversionBasedUnit", IfcNamedUnit_type); - entity* IfcCurveStyle_type = new entity("IfcCurveStyle", IfcPresentationStyle_type); - entity* IfcDerivedProfileDef_type = new entity("IfcDerivedProfileDef", IfcProfileDef_type); - entity* IfcDimensionCalloutRelationship_type = new entity("IfcDimensionCalloutRelationship", IfcDraughtingCalloutRelationship_type); - entity* IfcDimensionPair_type = new entity("IfcDimensionPair", IfcDraughtingCalloutRelationship_type); - entity* IfcDocumentReference_type = new entity("IfcDocumentReference", IfcExternalReference_type); - entity* IfcDraughtingPreDefinedTextFont_type = new entity("IfcDraughtingPreDefinedTextFont", IfcPreDefinedTextFont_type); - entity* IfcEdge_type = new entity("IfcEdge", IfcTopologicalRepresentationItem_type); - entity* IfcEdgeCurve_type = new entity("IfcEdgeCurve", IfcEdge_type); - entity* IfcExtendedMaterialProperties_type = new entity("IfcExtendedMaterialProperties", IfcMaterialProperties_type); - entity* IfcFace_type = new entity("IfcFace", IfcTopologicalRepresentationItem_type); - entity* IfcFaceBound_type = new entity("IfcFaceBound", IfcTopologicalRepresentationItem_type); - entity* IfcFaceOuterBound_type = new entity("IfcFaceOuterBound", IfcFaceBound_type); - entity* IfcFaceSurface_type = new entity("IfcFaceSurface", IfcFace_type); - entity* IfcFailureConnectionCondition_type = new entity("IfcFailureConnectionCondition", IfcStructuralConnectionCondition_type); - entity* IfcFillAreaStyle_type = new entity("IfcFillAreaStyle", IfcPresentationStyle_type); - entity* IfcFuelProperties_type = new entity("IfcFuelProperties", IfcMaterialProperties_type); - entity* IfcGeneralMaterialProperties_type = new entity("IfcGeneralMaterialProperties", IfcMaterialProperties_type); - entity* IfcGeneralProfileProperties_type = new entity("IfcGeneralProfileProperties", IfcProfileProperties_type); - entity* IfcGeometricRepresentationContext_type = new entity("IfcGeometricRepresentationContext", IfcRepresentationContext_type); - entity* IfcGeometricRepresentationItem_type = new entity("IfcGeometricRepresentationItem", IfcRepresentationItem_type); - entity* IfcGeometricRepresentationSubContext_type = new entity("IfcGeometricRepresentationSubContext", IfcGeometricRepresentationContext_type); - entity* IfcGeometricSet_type = new entity("IfcGeometricSet", IfcGeometricRepresentationItem_type); - entity* IfcGridPlacement_type = new entity("IfcGridPlacement", IfcObjectPlacement_type); - entity* IfcHalfSpaceSolid_type = new entity("IfcHalfSpaceSolid", IfcGeometricRepresentationItem_type); - entity* IfcHygroscopicMaterialProperties_type = new entity("IfcHygroscopicMaterialProperties", IfcMaterialProperties_type); - entity* IfcImageTexture_type = new entity("IfcImageTexture", IfcSurfaceTexture_type); - entity* IfcIrregularTimeSeries_type = new entity("IfcIrregularTimeSeries", IfcTimeSeries_type); - entity* IfcLightSource_type = new entity("IfcLightSource", IfcGeometricRepresentationItem_type); - entity* IfcLightSourceAmbient_type = new entity("IfcLightSourceAmbient", IfcLightSource_type); - entity* IfcLightSourceDirectional_type = new entity("IfcLightSourceDirectional", IfcLightSource_type); - entity* IfcLightSourceGoniometric_type = new entity("IfcLightSourceGoniometric", IfcLightSource_type); - entity* IfcLightSourcePositional_type = new entity("IfcLightSourcePositional", IfcLightSource_type); - entity* IfcLightSourceSpot_type = new entity("IfcLightSourceSpot", IfcLightSourcePositional_type); - entity* IfcLocalPlacement_type = new entity("IfcLocalPlacement", IfcObjectPlacement_type); - entity* IfcLoop_type = new entity("IfcLoop", IfcTopologicalRepresentationItem_type); - entity* IfcMappedItem_type = new entity("IfcMappedItem", IfcRepresentationItem_type); - entity* IfcMaterialDefinitionRepresentation_type = new entity("IfcMaterialDefinitionRepresentation", IfcProductRepresentation_type); - entity* IfcMechanicalConcreteMaterialProperties_type = new entity("IfcMechanicalConcreteMaterialProperties", IfcMechanicalMaterialProperties_type); - entity* IfcObjectDefinition_type = new entity("IfcObjectDefinition", IfcRoot_type); - entity* IfcOneDirectionRepeatFactor_type = new entity("IfcOneDirectionRepeatFactor", IfcGeometricRepresentationItem_type); - entity* IfcOpenShell_type = new entity("IfcOpenShell", IfcConnectedFaceSet_type); - entity* IfcOrientedEdge_type = new entity("IfcOrientedEdge", IfcEdge_type); - entity* IfcParameterizedProfileDef_type = new entity("IfcParameterizedProfileDef", IfcProfileDef_type); - entity* IfcPath_type = new entity("IfcPath", IfcTopologicalRepresentationItem_type); - entity* IfcPhysicalComplexQuantity_type = new entity("IfcPhysicalComplexQuantity", IfcPhysicalQuantity_type); - entity* IfcPixelTexture_type = new entity("IfcPixelTexture", IfcSurfaceTexture_type); - entity* IfcPlacement_type = new entity("IfcPlacement", IfcGeometricRepresentationItem_type); - entity* IfcPlanarExtent_type = new entity("IfcPlanarExtent", IfcGeometricRepresentationItem_type); - entity* IfcPoint_type = new entity("IfcPoint", IfcGeometricRepresentationItem_type); - entity* IfcPointOnCurve_type = new entity("IfcPointOnCurve", IfcPoint_type); - entity* IfcPointOnSurface_type = new entity("IfcPointOnSurface", IfcPoint_type); - entity* IfcPolyLoop_type = new entity("IfcPolyLoop", IfcLoop_type); - entity* IfcPolygonalBoundedHalfSpace_type = new entity("IfcPolygonalBoundedHalfSpace", IfcHalfSpaceSolid_type); - entity* IfcPreDefinedColour_type = new entity("IfcPreDefinedColour", IfcPreDefinedItem_type); - entity* IfcPreDefinedCurveFont_type = new entity("IfcPreDefinedCurveFont", IfcPreDefinedItem_type); - entity* IfcPreDefinedDimensionSymbol_type = new entity("IfcPreDefinedDimensionSymbol", IfcPreDefinedSymbol_type); - entity* IfcPreDefinedPointMarkerSymbol_type = new entity("IfcPreDefinedPointMarkerSymbol", IfcPreDefinedSymbol_type); - entity* IfcProductDefinitionShape_type = new entity("IfcProductDefinitionShape", IfcProductRepresentation_type); - entity* IfcPropertyBoundedValue_type = new entity("IfcPropertyBoundedValue", IfcSimpleProperty_type); - entity* IfcPropertyDefinition_type = new entity("IfcPropertyDefinition", IfcRoot_type); - entity* IfcPropertyEnumeratedValue_type = new entity("IfcPropertyEnumeratedValue", IfcSimpleProperty_type); - entity* IfcPropertyListValue_type = new entity("IfcPropertyListValue", IfcSimpleProperty_type); - entity* IfcPropertyReferenceValue_type = new entity("IfcPropertyReferenceValue", IfcSimpleProperty_type); - entity* IfcPropertySetDefinition_type = new entity("IfcPropertySetDefinition", IfcPropertyDefinition_type); - entity* IfcPropertySingleValue_type = new entity("IfcPropertySingleValue", IfcSimpleProperty_type); - entity* IfcPropertyTableValue_type = new entity("IfcPropertyTableValue", IfcSimpleProperty_type); - entity* IfcRectangleProfileDef_type = new entity("IfcRectangleProfileDef", IfcParameterizedProfileDef_type); - entity* IfcRegularTimeSeries_type = new entity("IfcRegularTimeSeries", IfcTimeSeries_type); - entity* IfcReinforcementDefinitionProperties_type = new entity("IfcReinforcementDefinitionProperties", IfcPropertySetDefinition_type); - entity* IfcRelationship_type = new entity("IfcRelationship", IfcRoot_type); - entity* IfcRoundedRectangleProfileDef_type = new entity("IfcRoundedRectangleProfileDef", IfcRectangleProfileDef_type); - entity* IfcSectionedSpine_type = new entity("IfcSectionedSpine", IfcGeometricRepresentationItem_type); - entity* IfcServiceLifeFactor_type = new entity("IfcServiceLifeFactor", IfcPropertySetDefinition_type); - entity* IfcShellBasedSurfaceModel_type = new entity("IfcShellBasedSurfaceModel", IfcGeometricRepresentationItem_type); - entity* IfcSlippageConnectionCondition_type = new entity("IfcSlippageConnectionCondition", IfcStructuralConnectionCondition_type); - entity* IfcSolidModel_type = new entity("IfcSolidModel", IfcGeometricRepresentationItem_type); - entity* IfcSoundProperties_type = new entity("IfcSoundProperties", IfcPropertySetDefinition_type); - entity* IfcSoundValue_type = new entity("IfcSoundValue", IfcPropertySetDefinition_type); - entity* IfcSpaceThermalLoadProperties_type = new entity("IfcSpaceThermalLoadProperties", IfcPropertySetDefinition_type); - entity* IfcStructuralLoadLinearForce_type = new entity("IfcStructuralLoadLinearForce", IfcStructuralLoadStatic_type); - entity* IfcStructuralLoadPlanarForce_type = new entity("IfcStructuralLoadPlanarForce", IfcStructuralLoadStatic_type); - entity* IfcStructuralLoadSingleDisplacement_type = new entity("IfcStructuralLoadSingleDisplacement", IfcStructuralLoadStatic_type); - entity* IfcStructuralLoadSingleDisplacementDistortion_type = new entity("IfcStructuralLoadSingleDisplacementDistortion", IfcStructuralLoadSingleDisplacement_type); - entity* IfcStructuralLoadSingleForce_type = new entity("IfcStructuralLoadSingleForce", IfcStructuralLoadStatic_type); - entity* IfcStructuralLoadSingleForceWarping_type = new entity("IfcStructuralLoadSingleForceWarping", IfcStructuralLoadSingleForce_type); - entity* IfcStructuralProfileProperties_type = new entity("IfcStructuralProfileProperties", IfcGeneralProfileProperties_type); - entity* IfcStructuralSteelProfileProperties_type = new entity("IfcStructuralSteelProfileProperties", IfcStructuralProfileProperties_type); - entity* IfcSubedge_type = new entity("IfcSubedge", IfcEdge_type); - entity* IfcSurface_type = new entity("IfcSurface", IfcGeometricRepresentationItem_type); - entity* IfcSurfaceStyleRendering_type = new entity("IfcSurfaceStyleRendering", IfcSurfaceStyleShading_type); - entity* IfcSweptAreaSolid_type = new entity("IfcSweptAreaSolid", IfcSolidModel_type); - entity* IfcSweptDiskSolid_type = new entity("IfcSweptDiskSolid", IfcSolidModel_type); - entity* IfcSweptSurface_type = new entity("IfcSweptSurface", IfcSurface_type); - entity* IfcTShapeProfileDef_type = new entity("IfcTShapeProfileDef", IfcParameterizedProfileDef_type); - entity* IfcTerminatorSymbol_type = new entity("IfcTerminatorSymbol", IfcAnnotationSymbolOccurrence_type); - entity* IfcTextLiteral_type = new entity("IfcTextLiteral", IfcGeometricRepresentationItem_type); - entity* IfcTextLiteralWithExtent_type = new entity("IfcTextLiteralWithExtent", IfcTextLiteral_type); - entity* IfcTrapeziumProfileDef_type = new entity("IfcTrapeziumProfileDef", IfcParameterizedProfileDef_type); - entity* IfcTwoDirectionRepeatFactor_type = new entity("IfcTwoDirectionRepeatFactor", IfcOneDirectionRepeatFactor_type); - entity* IfcTypeObject_type = new entity("IfcTypeObject", IfcObjectDefinition_type); - entity* IfcTypeProduct_type = new entity("IfcTypeProduct", IfcTypeObject_type); - entity* IfcUShapeProfileDef_type = new entity("IfcUShapeProfileDef", IfcParameterizedProfileDef_type); - entity* IfcVector_type = new entity("IfcVector", IfcGeometricRepresentationItem_type); - entity* IfcVertexLoop_type = new entity("IfcVertexLoop", IfcLoop_type); - entity* IfcWindowLiningProperties_type = new entity("IfcWindowLiningProperties", IfcPropertySetDefinition_type); - entity* IfcWindowPanelProperties_type = new entity("IfcWindowPanelProperties", IfcPropertySetDefinition_type); - entity* IfcWindowStyle_type = new entity("IfcWindowStyle", IfcTypeProduct_type); - entity* IfcZShapeProfileDef_type = new entity("IfcZShapeProfileDef", IfcParameterizedProfileDef_type); - entity* IfcAnnotationCurveOccurrence_type = new entity("IfcAnnotationCurveOccurrence", IfcAnnotationOccurrence_type); - entity* IfcAnnotationFillArea_type = new entity("IfcAnnotationFillArea", IfcGeometricRepresentationItem_type); - entity* IfcAnnotationFillAreaOccurrence_type = new entity("IfcAnnotationFillAreaOccurrence", IfcAnnotationOccurrence_type); - entity* IfcAnnotationSurface_type = new entity("IfcAnnotationSurface", IfcGeometricRepresentationItem_type); - entity* IfcAxis1Placement_type = new entity("IfcAxis1Placement", IfcPlacement_type); - entity* IfcAxis2Placement2D_type = new entity("IfcAxis2Placement2D", IfcPlacement_type); - entity* IfcAxis2Placement3D_type = new entity("IfcAxis2Placement3D", IfcPlacement_type); - entity* IfcBooleanResult_type = new entity("IfcBooleanResult", IfcGeometricRepresentationItem_type); - entity* IfcBoundedSurface_type = new entity("IfcBoundedSurface", IfcSurface_type); - entity* IfcBoundingBox_type = new entity("IfcBoundingBox", IfcGeometricRepresentationItem_type); - entity* IfcBoxedHalfSpace_type = new entity("IfcBoxedHalfSpace", IfcHalfSpaceSolid_type); - entity* IfcCShapeProfileDef_type = new entity("IfcCShapeProfileDef", IfcParameterizedProfileDef_type); - entity* IfcCartesianPoint_type = new entity("IfcCartesianPoint", IfcPoint_type); - entity* IfcCartesianTransformationOperator_type = new entity("IfcCartesianTransformationOperator", IfcGeometricRepresentationItem_type); - entity* IfcCartesianTransformationOperator2D_type = new entity("IfcCartesianTransformationOperator2D", IfcCartesianTransformationOperator_type); - entity* IfcCartesianTransformationOperator2DnonUniform_type = new entity("IfcCartesianTransformationOperator2DnonUniform", IfcCartesianTransformationOperator2D_type); - entity* IfcCartesianTransformationOperator3D_type = new entity("IfcCartesianTransformationOperator3D", IfcCartesianTransformationOperator_type); - entity* IfcCartesianTransformationOperator3DnonUniform_type = new entity("IfcCartesianTransformationOperator3DnonUniform", IfcCartesianTransformationOperator3D_type); - entity* IfcCircleProfileDef_type = new entity("IfcCircleProfileDef", IfcParameterizedProfileDef_type); - entity* IfcClosedShell_type = new entity("IfcClosedShell", IfcConnectedFaceSet_type); - entity* IfcCompositeCurveSegment_type = new entity("IfcCompositeCurveSegment", IfcGeometricRepresentationItem_type); - entity* IfcCraneRailAShapeProfileDef_type = new entity("IfcCraneRailAShapeProfileDef", IfcParameterizedProfileDef_type); - entity* IfcCraneRailFShapeProfileDef_type = new entity("IfcCraneRailFShapeProfileDef", IfcParameterizedProfileDef_type); - entity* IfcCsgPrimitive3D_type = new entity("IfcCsgPrimitive3D", IfcGeometricRepresentationItem_type); - entity* IfcCsgSolid_type = new entity("IfcCsgSolid", IfcSolidModel_type); - entity* IfcCurve_type = new entity("IfcCurve", IfcGeometricRepresentationItem_type); - entity* IfcCurveBoundedPlane_type = new entity("IfcCurveBoundedPlane", IfcBoundedSurface_type); - entity* IfcDefinedSymbol_type = new entity("IfcDefinedSymbol", IfcGeometricRepresentationItem_type); - entity* IfcDimensionCurve_type = new entity("IfcDimensionCurve", IfcAnnotationCurveOccurrence_type); - entity* IfcDimensionCurveTerminator_type = new entity("IfcDimensionCurveTerminator", IfcTerminatorSymbol_type); - entity* IfcDirection_type = new entity("IfcDirection", IfcGeometricRepresentationItem_type); - entity* IfcDoorLiningProperties_type = new entity("IfcDoorLiningProperties", IfcPropertySetDefinition_type); - entity* IfcDoorPanelProperties_type = new entity("IfcDoorPanelProperties", IfcPropertySetDefinition_type); - entity* IfcDoorStyle_type = new entity("IfcDoorStyle", IfcTypeProduct_type); - entity* IfcDraughtingCallout_type = new entity("IfcDraughtingCallout", IfcGeometricRepresentationItem_type); - entity* IfcDraughtingPreDefinedColour_type = new entity("IfcDraughtingPreDefinedColour", IfcPreDefinedColour_type); - entity* IfcDraughtingPreDefinedCurveFont_type = new entity("IfcDraughtingPreDefinedCurveFont", IfcPreDefinedCurveFont_type); - entity* IfcEdgeLoop_type = new entity("IfcEdgeLoop", IfcLoop_type); - entity* IfcElementQuantity_type = new entity("IfcElementQuantity", IfcPropertySetDefinition_type); - entity* IfcElementType_type = new entity("IfcElementType", IfcTypeProduct_type); - entity* IfcElementarySurface_type = new entity("IfcElementarySurface", IfcSurface_type); - entity* IfcEllipseProfileDef_type = new entity("IfcEllipseProfileDef", IfcParameterizedProfileDef_type); - entity* IfcEnergyProperties_type = new entity("IfcEnergyProperties", IfcPropertySetDefinition_type); - entity* IfcExtrudedAreaSolid_type = new entity("IfcExtrudedAreaSolid", IfcSweptAreaSolid_type); - entity* IfcFaceBasedSurfaceModel_type = new entity("IfcFaceBasedSurfaceModel", IfcGeometricRepresentationItem_type); - entity* IfcFillAreaStyleHatching_type = new entity("IfcFillAreaStyleHatching", IfcGeometricRepresentationItem_type); - entity* IfcFillAreaStyleTileSymbolWithStyle_type = new entity("IfcFillAreaStyleTileSymbolWithStyle", IfcGeometricRepresentationItem_type); - entity* IfcFillAreaStyleTiles_type = new entity("IfcFillAreaStyleTiles", IfcGeometricRepresentationItem_type); - entity* IfcFluidFlowProperties_type = new entity("IfcFluidFlowProperties", IfcPropertySetDefinition_type); - entity* IfcFurnishingElementType_type = new entity("IfcFurnishingElementType", IfcElementType_type); - entity* IfcFurnitureType_type = new entity("IfcFurnitureType", IfcFurnishingElementType_type); - entity* IfcGeometricCurveSet_type = new entity("IfcGeometricCurveSet", IfcGeometricSet_type); - entity* IfcIShapeProfileDef_type = new entity("IfcIShapeProfileDef", IfcParameterizedProfileDef_type); - entity* IfcLShapeProfileDef_type = new entity("IfcLShapeProfileDef", IfcParameterizedProfileDef_type); - entity* IfcLine_type = new entity("IfcLine", IfcCurve_type); - entity* IfcManifoldSolidBrep_type = new entity("IfcManifoldSolidBrep", IfcSolidModel_type); - entity* IfcObject_type = new entity("IfcObject", IfcObjectDefinition_type); - entity* IfcOffsetCurve2D_type = new entity("IfcOffsetCurve2D", IfcCurve_type); - entity* IfcOffsetCurve3D_type = new entity("IfcOffsetCurve3D", IfcCurve_type); - entity* IfcPermeableCoveringProperties_type = new entity("IfcPermeableCoveringProperties", IfcPropertySetDefinition_type); - entity* IfcPlanarBox_type = new entity("IfcPlanarBox", IfcPlanarExtent_type); - entity* IfcPlane_type = new entity("IfcPlane", IfcElementarySurface_type); - entity* IfcProcess_type = new entity("IfcProcess", IfcObject_type); - entity* IfcProduct_type = new entity("IfcProduct", IfcObject_type); - entity* IfcProject_type = new entity("IfcProject", IfcObject_type); - entity* IfcProjectionCurve_type = new entity("IfcProjectionCurve", IfcAnnotationCurveOccurrence_type); - entity* IfcPropertySet_type = new entity("IfcPropertySet", IfcPropertySetDefinition_type); - entity* IfcProxy_type = new entity("IfcProxy", IfcProduct_type); - entity* IfcRectangleHollowProfileDef_type = new entity("IfcRectangleHollowProfileDef", IfcRectangleProfileDef_type); - entity* IfcRectangularPyramid_type = new entity("IfcRectangularPyramid", IfcCsgPrimitive3D_type); - entity* IfcRectangularTrimmedSurface_type = new entity("IfcRectangularTrimmedSurface", IfcBoundedSurface_type); - entity* IfcRelAssigns_type = new entity("IfcRelAssigns", IfcRelationship_type); - entity* IfcRelAssignsToActor_type = new entity("IfcRelAssignsToActor", IfcRelAssigns_type); - entity* IfcRelAssignsToControl_type = new entity("IfcRelAssignsToControl", IfcRelAssigns_type); - entity* IfcRelAssignsToGroup_type = new entity("IfcRelAssignsToGroup", IfcRelAssigns_type); - entity* IfcRelAssignsToProcess_type = new entity("IfcRelAssignsToProcess", IfcRelAssigns_type); - entity* IfcRelAssignsToProduct_type = new entity("IfcRelAssignsToProduct", IfcRelAssigns_type); - entity* IfcRelAssignsToProjectOrder_type = new entity("IfcRelAssignsToProjectOrder", IfcRelAssignsToControl_type); - entity* IfcRelAssignsToResource_type = new entity("IfcRelAssignsToResource", IfcRelAssigns_type); - entity* IfcRelAssociates_type = new entity("IfcRelAssociates", IfcRelationship_type); - entity* IfcRelAssociatesAppliedValue_type = new entity("IfcRelAssociatesAppliedValue", IfcRelAssociates_type); - entity* IfcRelAssociatesApproval_type = new entity("IfcRelAssociatesApproval", IfcRelAssociates_type); - entity* IfcRelAssociatesClassification_type = new entity("IfcRelAssociatesClassification", IfcRelAssociates_type); - entity* IfcRelAssociatesConstraint_type = new entity("IfcRelAssociatesConstraint", IfcRelAssociates_type); - entity* IfcRelAssociatesDocument_type = new entity("IfcRelAssociatesDocument", IfcRelAssociates_type); - entity* IfcRelAssociatesLibrary_type = new entity("IfcRelAssociatesLibrary", IfcRelAssociates_type); - entity* IfcRelAssociatesMaterial_type = new entity("IfcRelAssociatesMaterial", IfcRelAssociates_type); - entity* IfcRelAssociatesProfileProperties_type = new entity("IfcRelAssociatesProfileProperties", IfcRelAssociates_type); - entity* IfcRelConnects_type = new entity("IfcRelConnects", IfcRelationship_type); - entity* IfcRelConnectsElements_type = new entity("IfcRelConnectsElements", IfcRelConnects_type); - entity* IfcRelConnectsPathElements_type = new entity("IfcRelConnectsPathElements", IfcRelConnectsElements_type); - entity* IfcRelConnectsPortToElement_type = new entity("IfcRelConnectsPortToElement", IfcRelConnects_type); - entity* IfcRelConnectsPorts_type = new entity("IfcRelConnectsPorts", IfcRelConnects_type); - entity* IfcRelConnectsStructuralActivity_type = new entity("IfcRelConnectsStructuralActivity", IfcRelConnects_type); - entity* IfcRelConnectsStructuralElement_type = new entity("IfcRelConnectsStructuralElement", IfcRelConnects_type); - entity* IfcRelConnectsStructuralMember_type = new entity("IfcRelConnectsStructuralMember", IfcRelConnects_type); - entity* IfcRelConnectsWithEccentricity_type = new entity("IfcRelConnectsWithEccentricity", IfcRelConnectsStructuralMember_type); - entity* IfcRelConnectsWithRealizingElements_type = new entity("IfcRelConnectsWithRealizingElements", IfcRelConnectsElements_type); - entity* IfcRelContainedInSpatialStructure_type = new entity("IfcRelContainedInSpatialStructure", IfcRelConnects_type); - entity* IfcRelCoversBldgElements_type = new entity("IfcRelCoversBldgElements", IfcRelConnects_type); - entity* IfcRelCoversSpaces_type = new entity("IfcRelCoversSpaces", IfcRelConnects_type); - entity* IfcRelDecomposes_type = new entity("IfcRelDecomposes", IfcRelationship_type); - entity* IfcRelDefines_type = new entity("IfcRelDefines", IfcRelationship_type); - entity* IfcRelDefinesByProperties_type = new entity("IfcRelDefinesByProperties", IfcRelDefines_type); - entity* IfcRelDefinesByType_type = new entity("IfcRelDefinesByType", IfcRelDefines_type); - entity* IfcRelFillsElement_type = new entity("IfcRelFillsElement", IfcRelConnects_type); - entity* IfcRelFlowControlElements_type = new entity("IfcRelFlowControlElements", IfcRelConnects_type); - entity* IfcRelInteractionRequirements_type = new entity("IfcRelInteractionRequirements", IfcRelConnects_type); - entity* IfcRelNests_type = new entity("IfcRelNests", IfcRelDecomposes_type); - entity* IfcRelOccupiesSpaces_type = new entity("IfcRelOccupiesSpaces", IfcRelAssignsToActor_type); - entity* IfcRelOverridesProperties_type = new entity("IfcRelOverridesProperties", IfcRelDefinesByProperties_type); - entity* IfcRelProjectsElement_type = new entity("IfcRelProjectsElement", IfcRelConnects_type); - entity* IfcRelReferencedInSpatialStructure_type = new entity("IfcRelReferencedInSpatialStructure", IfcRelConnects_type); - entity* IfcRelSchedulesCostItems_type = new entity("IfcRelSchedulesCostItems", IfcRelAssignsToControl_type); - entity* IfcRelSequence_type = new entity("IfcRelSequence", IfcRelConnects_type); - entity* IfcRelServicesBuildings_type = new entity("IfcRelServicesBuildings", IfcRelConnects_type); - entity* IfcRelSpaceBoundary_type = new entity("IfcRelSpaceBoundary", IfcRelConnects_type); - entity* IfcRelVoidsElement_type = new entity("IfcRelVoidsElement", IfcRelConnects_type); - entity* IfcResource_type = new entity("IfcResource", IfcObject_type); - entity* IfcRevolvedAreaSolid_type = new entity("IfcRevolvedAreaSolid", IfcSweptAreaSolid_type); - entity* IfcRightCircularCone_type = new entity("IfcRightCircularCone", IfcCsgPrimitive3D_type); - entity* IfcRightCircularCylinder_type = new entity("IfcRightCircularCylinder", IfcCsgPrimitive3D_type); - entity* IfcSpatialStructureElement_type = new entity("IfcSpatialStructureElement", IfcProduct_type); - entity* IfcSpatialStructureElementType_type = new entity("IfcSpatialStructureElementType", IfcElementType_type); - entity* IfcSphere_type = new entity("IfcSphere", IfcCsgPrimitive3D_type); - entity* IfcStructuralActivity_type = new entity("IfcStructuralActivity", IfcProduct_type); - entity* IfcStructuralItem_type = new entity("IfcStructuralItem", IfcProduct_type); - entity* IfcStructuralMember_type = new entity("IfcStructuralMember", IfcStructuralItem_type); - entity* IfcStructuralReaction_type = new entity("IfcStructuralReaction", IfcStructuralActivity_type); - entity* IfcStructuralSurfaceMember_type = new entity("IfcStructuralSurfaceMember", IfcStructuralMember_type); - entity* IfcStructuralSurfaceMemberVarying_type = new entity("IfcStructuralSurfaceMemberVarying", IfcStructuralSurfaceMember_type); - entity* IfcStructuredDimensionCallout_type = new entity("IfcStructuredDimensionCallout", IfcDraughtingCallout_type); - entity* IfcSurfaceCurveSweptAreaSolid_type = new entity("IfcSurfaceCurveSweptAreaSolid", IfcSweptAreaSolid_type); - entity* IfcSurfaceOfLinearExtrusion_type = new entity("IfcSurfaceOfLinearExtrusion", IfcSweptSurface_type); - entity* IfcSurfaceOfRevolution_type = new entity("IfcSurfaceOfRevolution", IfcSweptSurface_type); - entity* IfcSystemFurnitureElementType_type = new entity("IfcSystemFurnitureElementType", IfcFurnishingElementType_type); - entity* IfcTask_type = new entity("IfcTask", IfcProcess_type); - entity* IfcTransportElementType_type = new entity("IfcTransportElementType", IfcElementType_type); - entity* IfcActor_type = new entity("IfcActor", IfcObject_type); - entity* IfcAnnotation_type = new entity("IfcAnnotation", IfcProduct_type); - entity* IfcAsymmetricIShapeProfileDef_type = new entity("IfcAsymmetricIShapeProfileDef", IfcIShapeProfileDef_type); - entity* IfcBlock_type = new entity("IfcBlock", IfcCsgPrimitive3D_type); - entity* IfcBooleanClippingResult_type = new entity("IfcBooleanClippingResult", IfcBooleanResult_type); - entity* IfcBoundedCurve_type = new entity("IfcBoundedCurve", IfcCurve_type); - entity* IfcBuilding_type = new entity("IfcBuilding", IfcSpatialStructureElement_type); - entity* IfcBuildingElementType_type = new entity("IfcBuildingElementType", IfcElementType_type); - entity* IfcBuildingStorey_type = new entity("IfcBuildingStorey", IfcSpatialStructureElement_type); - entity* IfcCircleHollowProfileDef_type = new entity("IfcCircleHollowProfileDef", IfcCircleProfileDef_type); - entity* IfcColumnType_type = new entity("IfcColumnType", IfcBuildingElementType_type); - entity* IfcCompositeCurve_type = new entity("IfcCompositeCurve", IfcBoundedCurve_type); - entity* IfcConic_type = new entity("IfcConic", IfcCurve_type); - entity* IfcConstructionResource_type = new entity("IfcConstructionResource", IfcResource_type); - entity* IfcControl_type = new entity("IfcControl", IfcObject_type); - entity* IfcCostItem_type = new entity("IfcCostItem", IfcControl_type); - entity* IfcCostSchedule_type = new entity("IfcCostSchedule", IfcControl_type); - entity* IfcCoveringType_type = new entity("IfcCoveringType", IfcBuildingElementType_type); - entity* IfcCrewResource_type = new entity("IfcCrewResource", IfcConstructionResource_type); - entity* IfcCurtainWallType_type = new entity("IfcCurtainWallType", IfcBuildingElementType_type); - entity* IfcDimensionCurveDirectedCallout_type = new entity("IfcDimensionCurveDirectedCallout", IfcDraughtingCallout_type); - entity* IfcDistributionElementType_type = new entity("IfcDistributionElementType", IfcElementType_type); - entity* IfcDistributionFlowElementType_type = new entity("IfcDistributionFlowElementType", IfcDistributionElementType_type); - entity* IfcElectricalBaseProperties_type = new entity("IfcElectricalBaseProperties", IfcEnergyProperties_type); - entity* IfcElement_type = new entity("IfcElement", IfcProduct_type); - entity* IfcElementAssembly_type = new entity("IfcElementAssembly", IfcElement_type); - entity* IfcElementComponent_type = new entity("IfcElementComponent", IfcElement_type); - entity* IfcElementComponentType_type = new entity("IfcElementComponentType", IfcElementType_type); - entity* IfcEllipse_type = new entity("IfcEllipse", IfcConic_type); - entity* IfcEnergyConversionDeviceType_type = new entity("IfcEnergyConversionDeviceType", IfcDistributionFlowElementType_type); - entity* IfcEquipmentElement_type = new entity("IfcEquipmentElement", IfcElement_type); - entity* IfcEquipmentStandard_type = new entity("IfcEquipmentStandard", IfcControl_type); - entity* IfcEvaporativeCoolerType_type = new entity("IfcEvaporativeCoolerType", IfcEnergyConversionDeviceType_type); - entity* IfcEvaporatorType_type = new entity("IfcEvaporatorType", IfcEnergyConversionDeviceType_type); - entity* IfcFacetedBrep_type = new entity("IfcFacetedBrep", IfcManifoldSolidBrep_type); - entity* IfcFacetedBrepWithVoids_type = new entity("IfcFacetedBrepWithVoids", IfcManifoldSolidBrep_type); - entity* IfcFastener_type = new entity("IfcFastener", IfcElementComponent_type); - entity* IfcFastenerType_type = new entity("IfcFastenerType", IfcElementComponentType_type); - entity* IfcFeatureElement_type = new entity("IfcFeatureElement", IfcElement_type); - entity* IfcFeatureElementAddition_type = new entity("IfcFeatureElementAddition", IfcFeatureElement_type); - entity* IfcFeatureElementSubtraction_type = new entity("IfcFeatureElementSubtraction", IfcFeatureElement_type); - entity* IfcFlowControllerType_type = new entity("IfcFlowControllerType", IfcDistributionFlowElementType_type); - entity* IfcFlowFittingType_type = new entity("IfcFlowFittingType", IfcDistributionFlowElementType_type); - entity* IfcFlowMeterType_type = new entity("IfcFlowMeterType", IfcFlowControllerType_type); - entity* IfcFlowMovingDeviceType_type = new entity("IfcFlowMovingDeviceType", IfcDistributionFlowElementType_type); - entity* IfcFlowSegmentType_type = new entity("IfcFlowSegmentType", IfcDistributionFlowElementType_type); - entity* IfcFlowStorageDeviceType_type = new entity("IfcFlowStorageDeviceType", IfcDistributionFlowElementType_type); - entity* IfcFlowTerminalType_type = new entity("IfcFlowTerminalType", IfcDistributionFlowElementType_type); - entity* IfcFlowTreatmentDeviceType_type = new entity("IfcFlowTreatmentDeviceType", IfcDistributionFlowElementType_type); - entity* IfcFurnishingElement_type = new entity("IfcFurnishingElement", IfcElement_type); - entity* IfcFurnitureStandard_type = new entity("IfcFurnitureStandard", IfcControl_type); - entity* IfcGasTerminalType_type = new entity("IfcGasTerminalType", IfcFlowTerminalType_type); - entity* IfcGrid_type = new entity("IfcGrid", IfcProduct_type); - entity* IfcGroup_type = new entity("IfcGroup", IfcObject_type); - entity* IfcHeatExchangerType_type = new entity("IfcHeatExchangerType", IfcEnergyConversionDeviceType_type); - entity* IfcHumidifierType_type = new entity("IfcHumidifierType", IfcEnergyConversionDeviceType_type); - entity* IfcInventory_type = new entity("IfcInventory", IfcGroup_type); - entity* IfcJunctionBoxType_type = new entity("IfcJunctionBoxType", IfcFlowFittingType_type); - entity* IfcLaborResource_type = new entity("IfcLaborResource", IfcConstructionResource_type); - entity* IfcLampType_type = new entity("IfcLampType", IfcFlowTerminalType_type); - entity* IfcLightFixtureType_type = new entity("IfcLightFixtureType", IfcFlowTerminalType_type); - entity* IfcLinearDimension_type = new entity("IfcLinearDimension", IfcDimensionCurveDirectedCallout_type); - entity* IfcMechanicalFastener_type = new entity("IfcMechanicalFastener", IfcFastener_type); - entity* IfcMechanicalFastenerType_type = new entity("IfcMechanicalFastenerType", IfcFastenerType_type); - entity* IfcMemberType_type = new entity("IfcMemberType", IfcBuildingElementType_type); - entity* IfcMotorConnectionType_type = new entity("IfcMotorConnectionType", IfcEnergyConversionDeviceType_type); - entity* IfcMove_type = new entity("IfcMove", IfcTask_type); - entity* IfcOccupant_type = new entity("IfcOccupant", IfcActor_type); - entity* IfcOpeningElement_type = new entity("IfcOpeningElement", IfcFeatureElementSubtraction_type); - entity* IfcOrderAction_type = new entity("IfcOrderAction", IfcTask_type); - entity* IfcOutletType_type = new entity("IfcOutletType", IfcFlowTerminalType_type); - entity* IfcPerformanceHistory_type = new entity("IfcPerformanceHistory", IfcControl_type); - entity* IfcPermit_type = new entity("IfcPermit", IfcControl_type); - entity* IfcPipeFittingType_type = new entity("IfcPipeFittingType", IfcFlowFittingType_type); - entity* IfcPipeSegmentType_type = new entity("IfcPipeSegmentType", IfcFlowSegmentType_type); - entity* IfcPlateType_type = new entity("IfcPlateType", IfcBuildingElementType_type); - entity* IfcPolyline_type = new entity("IfcPolyline", IfcBoundedCurve_type); - entity* IfcPort_type = new entity("IfcPort", IfcProduct_type); - entity* IfcProcedure_type = new entity("IfcProcedure", IfcProcess_type); - entity* IfcProjectOrder_type = new entity("IfcProjectOrder", IfcControl_type); - entity* IfcProjectOrderRecord_type = new entity("IfcProjectOrderRecord", IfcControl_type); - entity* IfcProjectionElement_type = new entity("IfcProjectionElement", IfcFeatureElementAddition_type); - entity* IfcProtectiveDeviceType_type = new entity("IfcProtectiveDeviceType", IfcFlowControllerType_type); - entity* IfcPumpType_type = new entity("IfcPumpType", IfcFlowMovingDeviceType_type); - entity* IfcRadiusDimension_type = new entity("IfcRadiusDimension", IfcDimensionCurveDirectedCallout_type); - entity* IfcRailingType_type = new entity("IfcRailingType", IfcBuildingElementType_type); - entity* IfcRampFlightType_type = new entity("IfcRampFlightType", IfcBuildingElementType_type); - entity* IfcRelAggregates_type = new entity("IfcRelAggregates", IfcRelDecomposes_type); - entity* IfcRelAssignsTasks_type = new entity("IfcRelAssignsTasks", IfcRelAssignsToControl_type); - entity* IfcSanitaryTerminalType_type = new entity("IfcSanitaryTerminalType", IfcFlowTerminalType_type); - entity* IfcScheduleTimeControl_type = new entity("IfcScheduleTimeControl", IfcControl_type); - entity* IfcServiceLife_type = new entity("IfcServiceLife", IfcControl_type); - entity* IfcSite_type = new entity("IfcSite", IfcSpatialStructureElement_type); - entity* IfcSlabType_type = new entity("IfcSlabType", IfcBuildingElementType_type); - entity* IfcSpace_type = new entity("IfcSpace", IfcSpatialStructureElement_type); - entity* IfcSpaceHeaterType_type = new entity("IfcSpaceHeaterType", IfcEnergyConversionDeviceType_type); - entity* IfcSpaceProgram_type = new entity("IfcSpaceProgram", IfcControl_type); - entity* IfcSpaceType_type = new entity("IfcSpaceType", IfcSpatialStructureElementType_type); - entity* IfcStackTerminalType_type = new entity("IfcStackTerminalType", IfcFlowTerminalType_type); - entity* IfcStairFlightType_type = new entity("IfcStairFlightType", IfcBuildingElementType_type); - entity* IfcStructuralAction_type = new entity("IfcStructuralAction", IfcStructuralActivity_type); - entity* IfcStructuralConnection_type = new entity("IfcStructuralConnection", IfcStructuralItem_type); - entity* IfcStructuralCurveConnection_type = new entity("IfcStructuralCurveConnection", IfcStructuralConnection_type); - entity* IfcStructuralCurveMember_type = new entity("IfcStructuralCurveMember", IfcStructuralMember_type); - entity* IfcStructuralCurveMemberVarying_type = new entity("IfcStructuralCurveMemberVarying", IfcStructuralCurveMember_type); - entity* IfcStructuralLinearAction_type = new entity("IfcStructuralLinearAction", IfcStructuralAction_type); - entity* IfcStructuralLinearActionVarying_type = new entity("IfcStructuralLinearActionVarying", IfcStructuralLinearAction_type); - entity* IfcStructuralLoadGroup_type = new entity("IfcStructuralLoadGroup", IfcGroup_type); - entity* IfcStructuralPlanarAction_type = new entity("IfcStructuralPlanarAction", IfcStructuralAction_type); - entity* IfcStructuralPlanarActionVarying_type = new entity("IfcStructuralPlanarActionVarying", IfcStructuralPlanarAction_type); - entity* IfcStructuralPointAction_type = new entity("IfcStructuralPointAction", IfcStructuralAction_type); - entity* IfcStructuralPointConnection_type = new entity("IfcStructuralPointConnection", IfcStructuralConnection_type); - entity* IfcStructuralPointReaction_type = new entity("IfcStructuralPointReaction", IfcStructuralReaction_type); - entity* IfcStructuralResultGroup_type = new entity("IfcStructuralResultGroup", IfcGroup_type); - entity* IfcStructuralSurfaceConnection_type = new entity("IfcStructuralSurfaceConnection", IfcStructuralConnection_type); - entity* IfcSubContractResource_type = new entity("IfcSubContractResource", IfcConstructionResource_type); - entity* IfcSwitchingDeviceType_type = new entity("IfcSwitchingDeviceType", IfcFlowControllerType_type); - entity* IfcSystem_type = new entity("IfcSystem", IfcGroup_type); - entity* IfcTankType_type = new entity("IfcTankType", IfcFlowStorageDeviceType_type); - entity* IfcTimeSeriesSchedule_type = new entity("IfcTimeSeriesSchedule", IfcControl_type); - entity* IfcTransformerType_type = new entity("IfcTransformerType", IfcEnergyConversionDeviceType_type); - entity* IfcTransportElement_type = new entity("IfcTransportElement", IfcElement_type); - entity* IfcTrimmedCurve_type = new entity("IfcTrimmedCurve", IfcBoundedCurve_type); - entity* IfcTubeBundleType_type = new entity("IfcTubeBundleType", IfcEnergyConversionDeviceType_type); - entity* IfcUnitaryEquipmentType_type = new entity("IfcUnitaryEquipmentType", IfcEnergyConversionDeviceType_type); - entity* IfcValveType_type = new entity("IfcValveType", IfcFlowControllerType_type); - entity* IfcVirtualElement_type = new entity("IfcVirtualElement", IfcElement_type); - entity* IfcWallType_type = new entity("IfcWallType", IfcBuildingElementType_type); - entity* IfcWasteTerminalType_type = new entity("IfcWasteTerminalType", IfcFlowTerminalType_type); - entity* IfcWorkControl_type = new entity("IfcWorkControl", IfcControl_type); - entity* IfcWorkPlan_type = new entity("IfcWorkPlan", IfcWorkControl_type); - entity* IfcWorkSchedule_type = new entity("IfcWorkSchedule", IfcWorkControl_type); - entity* IfcZone_type = new entity("IfcZone", IfcGroup_type); - entity* Ifc2DCompositeCurve_type = new entity("Ifc2DCompositeCurve", IfcCompositeCurve_type); - entity* IfcActionRequest_type = new entity("IfcActionRequest", IfcControl_type); - entity* IfcAirTerminalBoxType_type = new entity("IfcAirTerminalBoxType", IfcFlowControllerType_type); - entity* IfcAirTerminalType_type = new entity("IfcAirTerminalType", IfcFlowTerminalType_type); - entity* IfcAirToAirHeatRecoveryType_type = new entity("IfcAirToAirHeatRecoveryType", IfcEnergyConversionDeviceType_type); - entity* IfcAngularDimension_type = new entity("IfcAngularDimension", IfcDimensionCurveDirectedCallout_type); - entity* IfcAsset_type = new entity("IfcAsset", IfcGroup_type); - entity* IfcBSplineCurve_type = new entity("IfcBSplineCurve", IfcBoundedCurve_type); - entity* IfcBeamType_type = new entity("IfcBeamType", IfcBuildingElementType_type); - entity* IfcBezierCurve_type = new entity("IfcBezierCurve", IfcBSplineCurve_type); - entity* IfcBoilerType_type = new entity("IfcBoilerType", IfcEnergyConversionDeviceType_type); - entity* IfcBuildingElement_type = new entity("IfcBuildingElement", IfcElement_type); - entity* IfcBuildingElementComponent_type = new entity("IfcBuildingElementComponent", IfcBuildingElement_type); - entity* IfcBuildingElementPart_type = new entity("IfcBuildingElementPart", IfcBuildingElementComponent_type); - entity* IfcBuildingElementProxy_type = new entity("IfcBuildingElementProxy", IfcBuildingElement_type); - entity* IfcBuildingElementProxyType_type = new entity("IfcBuildingElementProxyType", IfcBuildingElementType_type); - entity* IfcCableCarrierFittingType_type = new entity("IfcCableCarrierFittingType", IfcFlowFittingType_type); - entity* IfcCableCarrierSegmentType_type = new entity("IfcCableCarrierSegmentType", IfcFlowSegmentType_type); - entity* IfcCableSegmentType_type = new entity("IfcCableSegmentType", IfcFlowSegmentType_type); - entity* IfcChillerType_type = new entity("IfcChillerType", IfcEnergyConversionDeviceType_type); - entity* IfcCircle_type = new entity("IfcCircle", IfcConic_type); - entity* IfcCoilType_type = new entity("IfcCoilType", IfcEnergyConversionDeviceType_type); - entity* IfcColumn_type = new entity("IfcColumn", IfcBuildingElement_type); - entity* IfcCompressorType_type = new entity("IfcCompressorType", IfcFlowMovingDeviceType_type); - entity* IfcCondenserType_type = new entity("IfcCondenserType", IfcEnergyConversionDeviceType_type); - entity* IfcCondition_type = new entity("IfcCondition", IfcGroup_type); - entity* IfcConditionCriterion_type = new entity("IfcConditionCriterion", IfcControl_type); - entity* IfcConstructionEquipmentResource_type = new entity("IfcConstructionEquipmentResource", IfcConstructionResource_type); - entity* IfcConstructionMaterialResource_type = new entity("IfcConstructionMaterialResource", IfcConstructionResource_type); - entity* IfcConstructionProductResource_type = new entity("IfcConstructionProductResource", IfcConstructionResource_type); - entity* IfcCooledBeamType_type = new entity("IfcCooledBeamType", IfcEnergyConversionDeviceType_type); - entity* IfcCoolingTowerType_type = new entity("IfcCoolingTowerType", IfcEnergyConversionDeviceType_type); - entity* IfcCovering_type = new entity("IfcCovering", IfcBuildingElement_type); - entity* IfcCurtainWall_type = new entity("IfcCurtainWall", IfcBuildingElement_type); - entity* IfcDamperType_type = new entity("IfcDamperType", IfcFlowControllerType_type); - entity* IfcDiameterDimension_type = new entity("IfcDiameterDimension", IfcDimensionCurveDirectedCallout_type); - entity* IfcDiscreteAccessory_type = new entity("IfcDiscreteAccessory", IfcElementComponent_type); - entity* IfcDiscreteAccessoryType_type = new entity("IfcDiscreteAccessoryType", IfcElementComponentType_type); - entity* IfcDistributionChamberElementType_type = new entity("IfcDistributionChamberElementType", IfcDistributionFlowElementType_type); - entity* IfcDistributionControlElementType_type = new entity("IfcDistributionControlElementType", IfcDistributionElementType_type); - entity* IfcDistributionElement_type = new entity("IfcDistributionElement", IfcElement_type); - entity* IfcDistributionFlowElement_type = new entity("IfcDistributionFlowElement", IfcDistributionElement_type); - entity* IfcDistributionPort_type = new entity("IfcDistributionPort", IfcPort_type); - entity* IfcDoor_type = new entity("IfcDoor", IfcBuildingElement_type); - entity* IfcDuctFittingType_type = new entity("IfcDuctFittingType", IfcFlowFittingType_type); - entity* IfcDuctSegmentType_type = new entity("IfcDuctSegmentType", IfcFlowSegmentType_type); - entity* IfcDuctSilencerType_type = new entity("IfcDuctSilencerType", IfcFlowTreatmentDeviceType_type); - entity* IfcEdgeFeature_type = new entity("IfcEdgeFeature", IfcFeatureElementSubtraction_type); - entity* IfcElectricApplianceType_type = new entity("IfcElectricApplianceType", IfcFlowTerminalType_type); - entity* IfcElectricFlowStorageDeviceType_type = new entity("IfcElectricFlowStorageDeviceType", IfcFlowStorageDeviceType_type); - entity* IfcElectricGeneratorType_type = new entity("IfcElectricGeneratorType", IfcEnergyConversionDeviceType_type); - entity* IfcElectricHeaterType_type = new entity("IfcElectricHeaterType", IfcFlowTerminalType_type); - entity* IfcElectricMotorType_type = new entity("IfcElectricMotorType", IfcEnergyConversionDeviceType_type); - entity* IfcElectricTimeControlType_type = new entity("IfcElectricTimeControlType", IfcFlowControllerType_type); - entity* IfcElectricalCircuit_type = new entity("IfcElectricalCircuit", IfcSystem_type); - entity* IfcElectricalElement_type = new entity("IfcElectricalElement", IfcElement_type); - entity* IfcEnergyConversionDevice_type = new entity("IfcEnergyConversionDevice", IfcDistributionFlowElement_type); - entity* IfcFanType_type = new entity("IfcFanType", IfcFlowMovingDeviceType_type); - entity* IfcFilterType_type = new entity("IfcFilterType", IfcFlowTreatmentDeviceType_type); - entity* IfcFireSuppressionTerminalType_type = new entity("IfcFireSuppressionTerminalType", IfcFlowTerminalType_type); - entity* IfcFlowController_type = new entity("IfcFlowController", IfcDistributionFlowElement_type); - entity* IfcFlowFitting_type = new entity("IfcFlowFitting", IfcDistributionFlowElement_type); - entity* IfcFlowInstrumentType_type = new entity("IfcFlowInstrumentType", IfcDistributionControlElementType_type); - entity* IfcFlowMovingDevice_type = new entity("IfcFlowMovingDevice", IfcDistributionFlowElement_type); - entity* IfcFlowSegment_type = new entity("IfcFlowSegment", IfcDistributionFlowElement_type); - entity* IfcFlowStorageDevice_type = new entity("IfcFlowStorageDevice", IfcDistributionFlowElement_type); - entity* IfcFlowTerminal_type = new entity("IfcFlowTerminal", IfcDistributionFlowElement_type); - entity* IfcFlowTreatmentDevice_type = new entity("IfcFlowTreatmentDevice", IfcDistributionFlowElement_type); - entity* IfcFooting_type = new entity("IfcFooting", IfcBuildingElement_type); - entity* IfcMember_type = new entity("IfcMember", IfcBuildingElement_type); - entity* IfcPile_type = new entity("IfcPile", IfcBuildingElement_type); - entity* IfcPlate_type = new entity("IfcPlate", IfcBuildingElement_type); - entity* IfcRailing_type = new entity("IfcRailing", IfcBuildingElement_type); - entity* IfcRamp_type = new entity("IfcRamp", IfcBuildingElement_type); - entity* IfcRampFlight_type = new entity("IfcRampFlight", IfcBuildingElement_type); - entity* IfcRationalBezierCurve_type = new entity("IfcRationalBezierCurve", IfcBezierCurve_type); - entity* IfcReinforcingElement_type = new entity("IfcReinforcingElement", IfcBuildingElementComponent_type); - entity* IfcReinforcingMesh_type = new entity("IfcReinforcingMesh", IfcReinforcingElement_type); - entity* IfcRoof_type = new entity("IfcRoof", IfcBuildingElement_type); - entity* IfcRoundedEdgeFeature_type = new entity("IfcRoundedEdgeFeature", IfcEdgeFeature_type); - entity* IfcSensorType_type = new entity("IfcSensorType", IfcDistributionControlElementType_type); - entity* IfcSlab_type = new entity("IfcSlab", IfcBuildingElement_type); - entity* IfcStair_type = new entity("IfcStair", IfcBuildingElement_type); - entity* IfcStairFlight_type = new entity("IfcStairFlight", IfcBuildingElement_type); - entity* IfcStructuralAnalysisModel_type = new entity("IfcStructuralAnalysisModel", IfcSystem_type); - entity* IfcTendon_type = new entity("IfcTendon", IfcReinforcingElement_type); - entity* IfcTendonAnchor_type = new entity("IfcTendonAnchor", IfcReinforcingElement_type); - entity* IfcVibrationIsolatorType_type = new entity("IfcVibrationIsolatorType", IfcDiscreteAccessoryType_type); - entity* IfcWall_type = new entity("IfcWall", IfcBuildingElement_type); - entity* IfcWallStandardCase_type = new entity("IfcWallStandardCase", IfcWall_type); - entity* IfcWindow_type = new entity("IfcWindow", IfcBuildingElement_type); - entity* IfcActuatorType_type = new entity("IfcActuatorType", IfcDistributionControlElementType_type); - entity* IfcAlarmType_type = new entity("IfcAlarmType", IfcDistributionControlElementType_type); - entity* IfcBeam_type = new entity("IfcBeam", IfcBuildingElement_type); - entity* IfcChamferEdgeFeature_type = new entity("IfcChamferEdgeFeature", IfcEdgeFeature_type); - entity* IfcControllerType_type = new entity("IfcControllerType", IfcDistributionControlElementType_type); - entity* IfcDistributionChamberElement_type = new entity("IfcDistributionChamberElement", IfcDistributionFlowElement_type); - entity* IfcDistributionControlElement_type = new entity("IfcDistributionControlElement", IfcDistributionElement_type); - entity* IfcElectricDistributionPoint_type = new entity("IfcElectricDistributionPoint", IfcFlowController_type); - entity* IfcReinforcingBar_type = new entity("IfcReinforcingBar", IfcReinforcingElement_type); - declaration* IfcActorSelect_type; + IfcActorRole_type = new entity(IfcSchema::Type::IfcActorRole, 0); + IfcAddress_type = new entity(IfcSchema::Type::IfcAddress, 0); + IfcApplication_type = new entity(IfcSchema::Type::IfcApplication, 0); + IfcAppliedValue_type = new entity(IfcSchema::Type::IfcAppliedValue, 0); + IfcAppliedValueRelationship_type = new entity(IfcSchema::Type::IfcAppliedValueRelationship, 0); + IfcApproval_type = new entity(IfcSchema::Type::IfcApproval, 0); + IfcApprovalActorRelationship_type = new entity(IfcSchema::Type::IfcApprovalActorRelationship, 0); + IfcApprovalPropertyRelationship_type = new entity(IfcSchema::Type::IfcApprovalPropertyRelationship, 0); + IfcApprovalRelationship_type = new entity(IfcSchema::Type::IfcApprovalRelationship, 0); + IfcBoundaryCondition_type = new entity(IfcSchema::Type::IfcBoundaryCondition, 0); + IfcBoundaryEdgeCondition_type = new entity(IfcSchema::Type::IfcBoundaryEdgeCondition, IfcBoundaryCondition_type); + IfcBoundaryFaceCondition_type = new entity(IfcSchema::Type::IfcBoundaryFaceCondition, IfcBoundaryCondition_type); + IfcBoundaryNodeCondition_type = new entity(IfcSchema::Type::IfcBoundaryNodeCondition, IfcBoundaryCondition_type); + IfcBoundaryNodeConditionWarping_type = new entity(IfcSchema::Type::IfcBoundaryNodeConditionWarping, IfcBoundaryNodeCondition_type); + IfcCalendarDate_type = new entity(IfcSchema::Type::IfcCalendarDate, 0); + IfcClassification_type = new entity(IfcSchema::Type::IfcClassification, 0); + IfcClassificationItem_type = new entity(IfcSchema::Type::IfcClassificationItem, 0); + IfcClassificationItemRelationship_type = new entity(IfcSchema::Type::IfcClassificationItemRelationship, 0); + IfcClassificationNotation_type = new entity(IfcSchema::Type::IfcClassificationNotation, 0); + IfcClassificationNotationFacet_type = new entity(IfcSchema::Type::IfcClassificationNotationFacet, 0); + IfcColourSpecification_type = new entity(IfcSchema::Type::IfcColourSpecification, 0); + IfcConnectionGeometry_type = new entity(IfcSchema::Type::IfcConnectionGeometry, 0); + IfcConnectionPointGeometry_type = new entity(IfcSchema::Type::IfcConnectionPointGeometry, IfcConnectionGeometry_type); + IfcConnectionPortGeometry_type = new entity(IfcSchema::Type::IfcConnectionPortGeometry, IfcConnectionGeometry_type); + IfcConnectionSurfaceGeometry_type = new entity(IfcSchema::Type::IfcConnectionSurfaceGeometry, IfcConnectionGeometry_type); + IfcConstraint_type = new entity(IfcSchema::Type::IfcConstraint, 0); + IfcConstraintAggregationRelationship_type = new entity(IfcSchema::Type::IfcConstraintAggregationRelationship, 0); + IfcConstraintClassificationRelationship_type = new entity(IfcSchema::Type::IfcConstraintClassificationRelationship, 0); + IfcConstraintRelationship_type = new entity(IfcSchema::Type::IfcConstraintRelationship, 0); + IfcCoordinatedUniversalTimeOffset_type = new entity(IfcSchema::Type::IfcCoordinatedUniversalTimeOffset, 0); + IfcCostValue_type = new entity(IfcSchema::Type::IfcCostValue, IfcAppliedValue_type); + IfcCurrencyRelationship_type = new entity(IfcSchema::Type::IfcCurrencyRelationship, 0); + IfcCurveStyleFont_type = new entity(IfcSchema::Type::IfcCurveStyleFont, 0); + IfcCurveStyleFontAndScaling_type = new entity(IfcSchema::Type::IfcCurveStyleFontAndScaling, 0); + IfcCurveStyleFontPattern_type = new entity(IfcSchema::Type::IfcCurveStyleFontPattern, 0); + IfcDateAndTime_type = new entity(IfcSchema::Type::IfcDateAndTime, 0); + IfcDerivedUnit_type = new entity(IfcSchema::Type::IfcDerivedUnit, 0); + IfcDerivedUnitElement_type = new entity(IfcSchema::Type::IfcDerivedUnitElement, 0); + IfcDimensionalExponents_type = new entity(IfcSchema::Type::IfcDimensionalExponents, 0); + IfcDocumentElectronicFormat_type = new entity(IfcSchema::Type::IfcDocumentElectronicFormat, 0); + IfcDocumentInformation_type = new entity(IfcSchema::Type::IfcDocumentInformation, 0); + IfcDocumentInformationRelationship_type = new entity(IfcSchema::Type::IfcDocumentInformationRelationship, 0); + IfcDraughtingCalloutRelationship_type = new entity(IfcSchema::Type::IfcDraughtingCalloutRelationship, 0); + IfcEnvironmentalImpactValue_type = new entity(IfcSchema::Type::IfcEnvironmentalImpactValue, IfcAppliedValue_type); + IfcExternalReference_type = new entity(IfcSchema::Type::IfcExternalReference, 0); + IfcExternallyDefinedHatchStyle_type = new entity(IfcSchema::Type::IfcExternallyDefinedHatchStyle, IfcExternalReference_type); + IfcExternallyDefinedSurfaceStyle_type = new entity(IfcSchema::Type::IfcExternallyDefinedSurfaceStyle, IfcExternalReference_type); + IfcExternallyDefinedSymbol_type = new entity(IfcSchema::Type::IfcExternallyDefinedSymbol, IfcExternalReference_type); + IfcExternallyDefinedTextFont_type = new entity(IfcSchema::Type::IfcExternallyDefinedTextFont, IfcExternalReference_type); + IfcGridAxis_type = new entity(IfcSchema::Type::IfcGridAxis, 0); + IfcIrregularTimeSeriesValue_type = new entity(IfcSchema::Type::IfcIrregularTimeSeriesValue, 0); + IfcLibraryInformation_type = new entity(IfcSchema::Type::IfcLibraryInformation, 0); + IfcLibraryReference_type = new entity(IfcSchema::Type::IfcLibraryReference, IfcExternalReference_type); + IfcLightDistributionData_type = new entity(IfcSchema::Type::IfcLightDistributionData, 0); + IfcLightIntensityDistribution_type = new entity(IfcSchema::Type::IfcLightIntensityDistribution, 0); + IfcLocalTime_type = new entity(IfcSchema::Type::IfcLocalTime, 0); + IfcMaterial_type = new entity(IfcSchema::Type::IfcMaterial, 0); + IfcMaterialClassificationRelationship_type = new entity(IfcSchema::Type::IfcMaterialClassificationRelationship, 0); + IfcMaterialLayer_type = new entity(IfcSchema::Type::IfcMaterialLayer, 0); + IfcMaterialLayerSet_type = new entity(IfcSchema::Type::IfcMaterialLayerSet, 0); + IfcMaterialLayerSetUsage_type = new entity(IfcSchema::Type::IfcMaterialLayerSetUsage, 0); + IfcMaterialList_type = new entity(IfcSchema::Type::IfcMaterialList, 0); + IfcMaterialProperties_type = new entity(IfcSchema::Type::IfcMaterialProperties, 0); + IfcMeasureWithUnit_type = new entity(IfcSchema::Type::IfcMeasureWithUnit, 0); + IfcMechanicalMaterialProperties_type = new entity(IfcSchema::Type::IfcMechanicalMaterialProperties, IfcMaterialProperties_type); + IfcMechanicalSteelMaterialProperties_type = new entity(IfcSchema::Type::IfcMechanicalSteelMaterialProperties, IfcMechanicalMaterialProperties_type); + IfcMetric_type = new entity(IfcSchema::Type::IfcMetric, IfcConstraint_type); + IfcMonetaryUnit_type = new entity(IfcSchema::Type::IfcMonetaryUnit, 0); + IfcNamedUnit_type = new entity(IfcSchema::Type::IfcNamedUnit, 0); + IfcObjectPlacement_type = new entity(IfcSchema::Type::IfcObjectPlacement, 0); + IfcObjective_type = new entity(IfcSchema::Type::IfcObjective, IfcConstraint_type); + IfcOpticalMaterialProperties_type = new entity(IfcSchema::Type::IfcOpticalMaterialProperties, IfcMaterialProperties_type); + IfcOrganization_type = new entity(IfcSchema::Type::IfcOrganization, 0); + IfcOrganizationRelationship_type = new entity(IfcSchema::Type::IfcOrganizationRelationship, 0); + IfcOwnerHistory_type = new entity(IfcSchema::Type::IfcOwnerHistory, 0); + IfcPerson_type = new entity(IfcSchema::Type::IfcPerson, 0); + IfcPersonAndOrganization_type = new entity(IfcSchema::Type::IfcPersonAndOrganization, 0); + IfcPhysicalQuantity_type = new entity(IfcSchema::Type::IfcPhysicalQuantity, 0); + IfcPhysicalSimpleQuantity_type = new entity(IfcSchema::Type::IfcPhysicalSimpleQuantity, IfcPhysicalQuantity_type); + IfcPostalAddress_type = new entity(IfcSchema::Type::IfcPostalAddress, IfcAddress_type); + IfcPreDefinedItem_type = new entity(IfcSchema::Type::IfcPreDefinedItem, 0); + IfcPreDefinedSymbol_type = new entity(IfcSchema::Type::IfcPreDefinedSymbol, IfcPreDefinedItem_type); + IfcPreDefinedTerminatorSymbol_type = new entity(IfcSchema::Type::IfcPreDefinedTerminatorSymbol, IfcPreDefinedSymbol_type); + IfcPreDefinedTextFont_type = new entity(IfcSchema::Type::IfcPreDefinedTextFont, IfcPreDefinedItem_type); + IfcPresentationLayerAssignment_type = new entity(IfcSchema::Type::IfcPresentationLayerAssignment, 0); + IfcPresentationLayerWithStyle_type = new entity(IfcSchema::Type::IfcPresentationLayerWithStyle, IfcPresentationLayerAssignment_type); + IfcPresentationStyle_type = new entity(IfcSchema::Type::IfcPresentationStyle, 0); + IfcPresentationStyleAssignment_type = new entity(IfcSchema::Type::IfcPresentationStyleAssignment, 0); + IfcProductRepresentation_type = new entity(IfcSchema::Type::IfcProductRepresentation, 0); + IfcProductsOfCombustionProperties_type = new entity(IfcSchema::Type::IfcProductsOfCombustionProperties, IfcMaterialProperties_type); + IfcProfileDef_type = new entity(IfcSchema::Type::IfcProfileDef, 0); + IfcProfileProperties_type = new entity(IfcSchema::Type::IfcProfileProperties, 0); + IfcProperty_type = new entity(IfcSchema::Type::IfcProperty, 0); + IfcPropertyConstraintRelationship_type = new entity(IfcSchema::Type::IfcPropertyConstraintRelationship, 0); + IfcPropertyDependencyRelationship_type = new entity(IfcSchema::Type::IfcPropertyDependencyRelationship, 0); + IfcPropertyEnumeration_type = new entity(IfcSchema::Type::IfcPropertyEnumeration, 0); + IfcQuantityArea_type = new entity(IfcSchema::Type::IfcQuantityArea, IfcPhysicalSimpleQuantity_type); + IfcQuantityCount_type = new entity(IfcSchema::Type::IfcQuantityCount, IfcPhysicalSimpleQuantity_type); + IfcQuantityLength_type = new entity(IfcSchema::Type::IfcQuantityLength, IfcPhysicalSimpleQuantity_type); + IfcQuantityTime_type = new entity(IfcSchema::Type::IfcQuantityTime, IfcPhysicalSimpleQuantity_type); + IfcQuantityVolume_type = new entity(IfcSchema::Type::IfcQuantityVolume, IfcPhysicalSimpleQuantity_type); + IfcQuantityWeight_type = new entity(IfcSchema::Type::IfcQuantityWeight, IfcPhysicalSimpleQuantity_type); + IfcReferencesValueDocument_type = new entity(IfcSchema::Type::IfcReferencesValueDocument, 0); + IfcReinforcementBarProperties_type = new entity(IfcSchema::Type::IfcReinforcementBarProperties, 0); + IfcRelaxation_type = new entity(IfcSchema::Type::IfcRelaxation, 0); + IfcRepresentation_type = new entity(IfcSchema::Type::IfcRepresentation, 0); + IfcRepresentationContext_type = new entity(IfcSchema::Type::IfcRepresentationContext, 0); + IfcRepresentationItem_type = new entity(IfcSchema::Type::IfcRepresentationItem, 0); + IfcRepresentationMap_type = new entity(IfcSchema::Type::IfcRepresentationMap, 0); + IfcRibPlateProfileProperties_type = new entity(IfcSchema::Type::IfcRibPlateProfileProperties, IfcProfileProperties_type); + IfcRoot_type = new entity(IfcSchema::Type::IfcRoot, 0); + IfcSIUnit_type = new entity(IfcSchema::Type::IfcSIUnit, IfcNamedUnit_type); + IfcSectionProperties_type = new entity(IfcSchema::Type::IfcSectionProperties, 0); + IfcSectionReinforcementProperties_type = new entity(IfcSchema::Type::IfcSectionReinforcementProperties, 0); + IfcShapeAspect_type = new entity(IfcSchema::Type::IfcShapeAspect, 0); + IfcShapeModel_type = new entity(IfcSchema::Type::IfcShapeModel, IfcRepresentation_type); + IfcShapeRepresentation_type = new entity(IfcSchema::Type::IfcShapeRepresentation, IfcShapeModel_type); + IfcSimpleProperty_type = new entity(IfcSchema::Type::IfcSimpleProperty, IfcProperty_type); + IfcStructuralConnectionCondition_type = new entity(IfcSchema::Type::IfcStructuralConnectionCondition, 0); + IfcStructuralLoad_type = new entity(IfcSchema::Type::IfcStructuralLoad, 0); + IfcStructuralLoadStatic_type = new entity(IfcSchema::Type::IfcStructuralLoadStatic, IfcStructuralLoad_type); + IfcStructuralLoadTemperature_type = new entity(IfcSchema::Type::IfcStructuralLoadTemperature, IfcStructuralLoadStatic_type); + IfcStyleModel_type = new entity(IfcSchema::Type::IfcStyleModel, IfcRepresentation_type); + IfcStyledItem_type = new entity(IfcSchema::Type::IfcStyledItem, IfcRepresentationItem_type); + IfcStyledRepresentation_type = new entity(IfcSchema::Type::IfcStyledRepresentation, IfcStyleModel_type); + IfcSurfaceStyle_type = new entity(IfcSchema::Type::IfcSurfaceStyle, IfcPresentationStyle_type); + IfcSurfaceStyleLighting_type = new entity(IfcSchema::Type::IfcSurfaceStyleLighting, 0); + IfcSurfaceStyleRefraction_type = new entity(IfcSchema::Type::IfcSurfaceStyleRefraction, 0); + IfcSurfaceStyleShading_type = new entity(IfcSchema::Type::IfcSurfaceStyleShading, 0); + IfcSurfaceStyleWithTextures_type = new entity(IfcSchema::Type::IfcSurfaceStyleWithTextures, 0); + IfcSurfaceTexture_type = new entity(IfcSchema::Type::IfcSurfaceTexture, 0); + IfcSymbolStyle_type = new entity(IfcSchema::Type::IfcSymbolStyle, IfcPresentationStyle_type); + IfcTable_type = new entity(IfcSchema::Type::IfcTable, 0); + IfcTableRow_type = new entity(IfcSchema::Type::IfcTableRow, 0); + IfcTelecomAddress_type = new entity(IfcSchema::Type::IfcTelecomAddress, IfcAddress_type); + IfcTextStyle_type = new entity(IfcSchema::Type::IfcTextStyle, IfcPresentationStyle_type); + IfcTextStyleFontModel_type = new entity(IfcSchema::Type::IfcTextStyleFontModel, IfcPreDefinedTextFont_type); + IfcTextStyleForDefinedFont_type = new entity(IfcSchema::Type::IfcTextStyleForDefinedFont, 0); + IfcTextStyleTextModel_type = new entity(IfcSchema::Type::IfcTextStyleTextModel, 0); + IfcTextStyleWithBoxCharacteristics_type = new entity(IfcSchema::Type::IfcTextStyleWithBoxCharacteristics, 0); + IfcTextureCoordinate_type = new entity(IfcSchema::Type::IfcTextureCoordinate, 0); + IfcTextureCoordinateGenerator_type = new entity(IfcSchema::Type::IfcTextureCoordinateGenerator, IfcTextureCoordinate_type); + IfcTextureMap_type = new entity(IfcSchema::Type::IfcTextureMap, IfcTextureCoordinate_type); + IfcTextureVertex_type = new entity(IfcSchema::Type::IfcTextureVertex, 0); + IfcThermalMaterialProperties_type = new entity(IfcSchema::Type::IfcThermalMaterialProperties, IfcMaterialProperties_type); + IfcTimeSeries_type = new entity(IfcSchema::Type::IfcTimeSeries, 0); + IfcTimeSeriesReferenceRelationship_type = new entity(IfcSchema::Type::IfcTimeSeriesReferenceRelationship, 0); + IfcTimeSeriesValue_type = new entity(IfcSchema::Type::IfcTimeSeriesValue, 0); + IfcTopologicalRepresentationItem_type = new entity(IfcSchema::Type::IfcTopologicalRepresentationItem, IfcRepresentationItem_type); + IfcTopologyRepresentation_type = new entity(IfcSchema::Type::IfcTopologyRepresentation, IfcShapeModel_type); + IfcUnitAssignment_type = new entity(IfcSchema::Type::IfcUnitAssignment, 0); + IfcVertex_type = new entity(IfcSchema::Type::IfcVertex, IfcTopologicalRepresentationItem_type); + IfcVertexBasedTextureMap_type = new entity(IfcSchema::Type::IfcVertexBasedTextureMap, 0); + IfcVertexPoint_type = new entity(IfcSchema::Type::IfcVertexPoint, IfcVertex_type); + IfcVirtualGridIntersection_type = new entity(IfcSchema::Type::IfcVirtualGridIntersection, 0); + IfcWaterProperties_type = new entity(IfcSchema::Type::IfcWaterProperties, IfcMaterialProperties_type); + IfcAnnotationOccurrence_type = new entity(IfcSchema::Type::IfcAnnotationOccurrence, IfcStyledItem_type); + IfcAnnotationSurfaceOccurrence_type = new entity(IfcSchema::Type::IfcAnnotationSurfaceOccurrence, IfcAnnotationOccurrence_type); + IfcAnnotationSymbolOccurrence_type = new entity(IfcSchema::Type::IfcAnnotationSymbolOccurrence, IfcAnnotationOccurrence_type); + IfcAnnotationTextOccurrence_type = new entity(IfcSchema::Type::IfcAnnotationTextOccurrence, IfcAnnotationOccurrence_type); + IfcArbitraryClosedProfileDef_type = new entity(IfcSchema::Type::IfcArbitraryClosedProfileDef, IfcProfileDef_type); + IfcArbitraryOpenProfileDef_type = new entity(IfcSchema::Type::IfcArbitraryOpenProfileDef, IfcProfileDef_type); + IfcArbitraryProfileDefWithVoids_type = new entity(IfcSchema::Type::IfcArbitraryProfileDefWithVoids, IfcArbitraryClosedProfileDef_type); + IfcBlobTexture_type = new entity(IfcSchema::Type::IfcBlobTexture, IfcSurfaceTexture_type); + IfcCenterLineProfileDef_type = new entity(IfcSchema::Type::IfcCenterLineProfileDef, IfcArbitraryOpenProfileDef_type); + IfcClassificationReference_type = new entity(IfcSchema::Type::IfcClassificationReference, IfcExternalReference_type); + IfcColourRgb_type = new entity(IfcSchema::Type::IfcColourRgb, IfcColourSpecification_type); + IfcComplexProperty_type = new entity(IfcSchema::Type::IfcComplexProperty, IfcProperty_type); + IfcCompositeProfileDef_type = new entity(IfcSchema::Type::IfcCompositeProfileDef, IfcProfileDef_type); + IfcConnectedFaceSet_type = new entity(IfcSchema::Type::IfcConnectedFaceSet, IfcTopologicalRepresentationItem_type); + IfcConnectionCurveGeometry_type = new entity(IfcSchema::Type::IfcConnectionCurveGeometry, IfcConnectionGeometry_type); + IfcConnectionPointEccentricity_type = new entity(IfcSchema::Type::IfcConnectionPointEccentricity, IfcConnectionPointGeometry_type); + IfcContextDependentUnit_type = new entity(IfcSchema::Type::IfcContextDependentUnit, IfcNamedUnit_type); + IfcConversionBasedUnit_type = new entity(IfcSchema::Type::IfcConversionBasedUnit, IfcNamedUnit_type); + IfcCurveStyle_type = new entity(IfcSchema::Type::IfcCurveStyle, IfcPresentationStyle_type); + IfcDerivedProfileDef_type = new entity(IfcSchema::Type::IfcDerivedProfileDef, IfcProfileDef_type); + IfcDimensionCalloutRelationship_type = new entity(IfcSchema::Type::IfcDimensionCalloutRelationship, IfcDraughtingCalloutRelationship_type); + IfcDimensionPair_type = new entity(IfcSchema::Type::IfcDimensionPair, IfcDraughtingCalloutRelationship_type); + IfcDocumentReference_type = new entity(IfcSchema::Type::IfcDocumentReference, IfcExternalReference_type); + IfcDraughtingPreDefinedTextFont_type = new entity(IfcSchema::Type::IfcDraughtingPreDefinedTextFont, IfcPreDefinedTextFont_type); + IfcEdge_type = new entity(IfcSchema::Type::IfcEdge, IfcTopologicalRepresentationItem_type); + IfcEdgeCurve_type = new entity(IfcSchema::Type::IfcEdgeCurve, IfcEdge_type); + IfcExtendedMaterialProperties_type = new entity(IfcSchema::Type::IfcExtendedMaterialProperties, IfcMaterialProperties_type); + IfcFace_type = new entity(IfcSchema::Type::IfcFace, IfcTopologicalRepresentationItem_type); + IfcFaceBound_type = new entity(IfcSchema::Type::IfcFaceBound, IfcTopologicalRepresentationItem_type); + IfcFaceOuterBound_type = new entity(IfcSchema::Type::IfcFaceOuterBound, IfcFaceBound_type); + IfcFaceSurface_type = new entity(IfcSchema::Type::IfcFaceSurface, IfcFace_type); + IfcFailureConnectionCondition_type = new entity(IfcSchema::Type::IfcFailureConnectionCondition, IfcStructuralConnectionCondition_type); + IfcFillAreaStyle_type = new entity(IfcSchema::Type::IfcFillAreaStyle, IfcPresentationStyle_type); + IfcFuelProperties_type = new entity(IfcSchema::Type::IfcFuelProperties, IfcMaterialProperties_type); + IfcGeneralMaterialProperties_type = new entity(IfcSchema::Type::IfcGeneralMaterialProperties, IfcMaterialProperties_type); + IfcGeneralProfileProperties_type = new entity(IfcSchema::Type::IfcGeneralProfileProperties, IfcProfileProperties_type); + IfcGeometricRepresentationContext_type = new entity(IfcSchema::Type::IfcGeometricRepresentationContext, IfcRepresentationContext_type); + IfcGeometricRepresentationItem_type = new entity(IfcSchema::Type::IfcGeometricRepresentationItem, IfcRepresentationItem_type); + IfcGeometricRepresentationSubContext_type = new entity(IfcSchema::Type::IfcGeometricRepresentationSubContext, IfcGeometricRepresentationContext_type); + IfcGeometricSet_type = new entity(IfcSchema::Type::IfcGeometricSet, IfcGeometricRepresentationItem_type); + IfcGridPlacement_type = new entity(IfcSchema::Type::IfcGridPlacement, IfcObjectPlacement_type); + IfcHalfSpaceSolid_type = new entity(IfcSchema::Type::IfcHalfSpaceSolid, IfcGeometricRepresentationItem_type); + IfcHygroscopicMaterialProperties_type = new entity(IfcSchema::Type::IfcHygroscopicMaterialProperties, IfcMaterialProperties_type); + IfcImageTexture_type = new entity(IfcSchema::Type::IfcImageTexture, IfcSurfaceTexture_type); + IfcIrregularTimeSeries_type = new entity(IfcSchema::Type::IfcIrregularTimeSeries, IfcTimeSeries_type); + IfcLightSource_type = new entity(IfcSchema::Type::IfcLightSource, IfcGeometricRepresentationItem_type); + IfcLightSourceAmbient_type = new entity(IfcSchema::Type::IfcLightSourceAmbient, IfcLightSource_type); + IfcLightSourceDirectional_type = new entity(IfcSchema::Type::IfcLightSourceDirectional, IfcLightSource_type); + IfcLightSourceGoniometric_type = new entity(IfcSchema::Type::IfcLightSourceGoniometric, IfcLightSource_type); + IfcLightSourcePositional_type = new entity(IfcSchema::Type::IfcLightSourcePositional, IfcLightSource_type); + IfcLightSourceSpot_type = new entity(IfcSchema::Type::IfcLightSourceSpot, IfcLightSourcePositional_type); + IfcLocalPlacement_type = new entity(IfcSchema::Type::IfcLocalPlacement, IfcObjectPlacement_type); + IfcLoop_type = new entity(IfcSchema::Type::IfcLoop, IfcTopologicalRepresentationItem_type); + IfcMappedItem_type = new entity(IfcSchema::Type::IfcMappedItem, IfcRepresentationItem_type); + IfcMaterialDefinitionRepresentation_type = new entity(IfcSchema::Type::IfcMaterialDefinitionRepresentation, IfcProductRepresentation_type); + IfcMechanicalConcreteMaterialProperties_type = new entity(IfcSchema::Type::IfcMechanicalConcreteMaterialProperties, IfcMechanicalMaterialProperties_type); + IfcObjectDefinition_type = new entity(IfcSchema::Type::IfcObjectDefinition, IfcRoot_type); + IfcOneDirectionRepeatFactor_type = new entity(IfcSchema::Type::IfcOneDirectionRepeatFactor, IfcGeometricRepresentationItem_type); + IfcOpenShell_type = new entity(IfcSchema::Type::IfcOpenShell, IfcConnectedFaceSet_type); + IfcOrientedEdge_type = new entity(IfcSchema::Type::IfcOrientedEdge, IfcEdge_type); + IfcParameterizedProfileDef_type = new entity(IfcSchema::Type::IfcParameterizedProfileDef, IfcProfileDef_type); + IfcPath_type = new entity(IfcSchema::Type::IfcPath, IfcTopologicalRepresentationItem_type); + IfcPhysicalComplexQuantity_type = new entity(IfcSchema::Type::IfcPhysicalComplexQuantity, IfcPhysicalQuantity_type); + IfcPixelTexture_type = new entity(IfcSchema::Type::IfcPixelTexture, IfcSurfaceTexture_type); + IfcPlacement_type = new entity(IfcSchema::Type::IfcPlacement, IfcGeometricRepresentationItem_type); + IfcPlanarExtent_type = new entity(IfcSchema::Type::IfcPlanarExtent, IfcGeometricRepresentationItem_type); + IfcPoint_type = new entity(IfcSchema::Type::IfcPoint, IfcGeometricRepresentationItem_type); + IfcPointOnCurve_type = new entity(IfcSchema::Type::IfcPointOnCurve, IfcPoint_type); + IfcPointOnSurface_type = new entity(IfcSchema::Type::IfcPointOnSurface, IfcPoint_type); + IfcPolyLoop_type = new entity(IfcSchema::Type::IfcPolyLoop, IfcLoop_type); + IfcPolygonalBoundedHalfSpace_type = new entity(IfcSchema::Type::IfcPolygonalBoundedHalfSpace, IfcHalfSpaceSolid_type); + IfcPreDefinedColour_type = new entity(IfcSchema::Type::IfcPreDefinedColour, IfcPreDefinedItem_type); + IfcPreDefinedCurveFont_type = new entity(IfcSchema::Type::IfcPreDefinedCurveFont, IfcPreDefinedItem_type); + IfcPreDefinedDimensionSymbol_type = new entity(IfcSchema::Type::IfcPreDefinedDimensionSymbol, IfcPreDefinedSymbol_type); + IfcPreDefinedPointMarkerSymbol_type = new entity(IfcSchema::Type::IfcPreDefinedPointMarkerSymbol, IfcPreDefinedSymbol_type); + IfcProductDefinitionShape_type = new entity(IfcSchema::Type::IfcProductDefinitionShape, IfcProductRepresentation_type); + IfcPropertyBoundedValue_type = new entity(IfcSchema::Type::IfcPropertyBoundedValue, IfcSimpleProperty_type); + IfcPropertyDefinition_type = new entity(IfcSchema::Type::IfcPropertyDefinition, IfcRoot_type); + IfcPropertyEnumeratedValue_type = new entity(IfcSchema::Type::IfcPropertyEnumeratedValue, IfcSimpleProperty_type); + IfcPropertyListValue_type = new entity(IfcSchema::Type::IfcPropertyListValue, IfcSimpleProperty_type); + IfcPropertyReferenceValue_type = new entity(IfcSchema::Type::IfcPropertyReferenceValue, IfcSimpleProperty_type); + IfcPropertySetDefinition_type = new entity(IfcSchema::Type::IfcPropertySetDefinition, IfcPropertyDefinition_type); + IfcPropertySingleValue_type = new entity(IfcSchema::Type::IfcPropertySingleValue, IfcSimpleProperty_type); + IfcPropertyTableValue_type = new entity(IfcSchema::Type::IfcPropertyTableValue, IfcSimpleProperty_type); + IfcRectangleProfileDef_type = new entity(IfcSchema::Type::IfcRectangleProfileDef, IfcParameterizedProfileDef_type); + IfcRegularTimeSeries_type = new entity(IfcSchema::Type::IfcRegularTimeSeries, IfcTimeSeries_type); + IfcReinforcementDefinitionProperties_type = new entity(IfcSchema::Type::IfcReinforcementDefinitionProperties, IfcPropertySetDefinition_type); + IfcRelationship_type = new entity(IfcSchema::Type::IfcRelationship, IfcRoot_type); + IfcRoundedRectangleProfileDef_type = new entity(IfcSchema::Type::IfcRoundedRectangleProfileDef, IfcRectangleProfileDef_type); + IfcSectionedSpine_type = new entity(IfcSchema::Type::IfcSectionedSpine, IfcGeometricRepresentationItem_type); + IfcServiceLifeFactor_type = new entity(IfcSchema::Type::IfcServiceLifeFactor, IfcPropertySetDefinition_type); + IfcShellBasedSurfaceModel_type = new entity(IfcSchema::Type::IfcShellBasedSurfaceModel, IfcGeometricRepresentationItem_type); + IfcSlippageConnectionCondition_type = new entity(IfcSchema::Type::IfcSlippageConnectionCondition, IfcStructuralConnectionCondition_type); + IfcSolidModel_type = new entity(IfcSchema::Type::IfcSolidModel, IfcGeometricRepresentationItem_type); + IfcSoundProperties_type = new entity(IfcSchema::Type::IfcSoundProperties, IfcPropertySetDefinition_type); + IfcSoundValue_type = new entity(IfcSchema::Type::IfcSoundValue, IfcPropertySetDefinition_type); + IfcSpaceThermalLoadProperties_type = new entity(IfcSchema::Type::IfcSpaceThermalLoadProperties, IfcPropertySetDefinition_type); + IfcStructuralLoadLinearForce_type = new entity(IfcSchema::Type::IfcStructuralLoadLinearForce, IfcStructuralLoadStatic_type); + IfcStructuralLoadPlanarForce_type = new entity(IfcSchema::Type::IfcStructuralLoadPlanarForce, IfcStructuralLoadStatic_type); + IfcStructuralLoadSingleDisplacement_type = new entity(IfcSchema::Type::IfcStructuralLoadSingleDisplacement, IfcStructuralLoadStatic_type); + IfcStructuralLoadSingleDisplacementDistortion_type = new entity(IfcSchema::Type::IfcStructuralLoadSingleDisplacementDistortion, IfcStructuralLoadSingleDisplacement_type); + IfcStructuralLoadSingleForce_type = new entity(IfcSchema::Type::IfcStructuralLoadSingleForce, IfcStructuralLoadStatic_type); + IfcStructuralLoadSingleForceWarping_type = new entity(IfcSchema::Type::IfcStructuralLoadSingleForceWarping, IfcStructuralLoadSingleForce_type); + IfcStructuralProfileProperties_type = new entity(IfcSchema::Type::IfcStructuralProfileProperties, IfcGeneralProfileProperties_type); + IfcStructuralSteelProfileProperties_type = new entity(IfcSchema::Type::IfcStructuralSteelProfileProperties, IfcStructuralProfileProperties_type); + IfcSubedge_type = new entity(IfcSchema::Type::IfcSubedge, IfcEdge_type); + IfcSurface_type = new entity(IfcSchema::Type::IfcSurface, IfcGeometricRepresentationItem_type); + IfcSurfaceStyleRendering_type = new entity(IfcSchema::Type::IfcSurfaceStyleRendering, IfcSurfaceStyleShading_type); + IfcSweptAreaSolid_type = new entity(IfcSchema::Type::IfcSweptAreaSolid, IfcSolidModel_type); + IfcSweptDiskSolid_type = new entity(IfcSchema::Type::IfcSweptDiskSolid, IfcSolidModel_type); + IfcSweptSurface_type = new entity(IfcSchema::Type::IfcSweptSurface, IfcSurface_type); + IfcTShapeProfileDef_type = new entity(IfcSchema::Type::IfcTShapeProfileDef, IfcParameterizedProfileDef_type); + IfcTerminatorSymbol_type = new entity(IfcSchema::Type::IfcTerminatorSymbol, IfcAnnotationSymbolOccurrence_type); + IfcTextLiteral_type = new entity(IfcSchema::Type::IfcTextLiteral, IfcGeometricRepresentationItem_type); + IfcTextLiteralWithExtent_type = new entity(IfcSchema::Type::IfcTextLiteralWithExtent, IfcTextLiteral_type); + IfcTrapeziumProfileDef_type = new entity(IfcSchema::Type::IfcTrapeziumProfileDef, IfcParameterizedProfileDef_type); + IfcTwoDirectionRepeatFactor_type = new entity(IfcSchema::Type::IfcTwoDirectionRepeatFactor, IfcOneDirectionRepeatFactor_type); + IfcTypeObject_type = new entity(IfcSchema::Type::IfcTypeObject, IfcObjectDefinition_type); + IfcTypeProduct_type = new entity(IfcSchema::Type::IfcTypeProduct, IfcTypeObject_type); + IfcUShapeProfileDef_type = new entity(IfcSchema::Type::IfcUShapeProfileDef, IfcParameterizedProfileDef_type); + IfcVector_type = new entity(IfcSchema::Type::IfcVector, IfcGeometricRepresentationItem_type); + IfcVertexLoop_type = new entity(IfcSchema::Type::IfcVertexLoop, IfcLoop_type); + IfcWindowLiningProperties_type = new entity(IfcSchema::Type::IfcWindowLiningProperties, IfcPropertySetDefinition_type); + IfcWindowPanelProperties_type = new entity(IfcSchema::Type::IfcWindowPanelProperties, IfcPropertySetDefinition_type); + IfcWindowStyle_type = new entity(IfcSchema::Type::IfcWindowStyle, IfcTypeProduct_type); + IfcZShapeProfileDef_type = new entity(IfcSchema::Type::IfcZShapeProfileDef, IfcParameterizedProfileDef_type); + IfcAnnotationCurveOccurrence_type = new entity(IfcSchema::Type::IfcAnnotationCurveOccurrence, IfcAnnotationOccurrence_type); + IfcAnnotationFillArea_type = new entity(IfcSchema::Type::IfcAnnotationFillArea, IfcGeometricRepresentationItem_type); + IfcAnnotationFillAreaOccurrence_type = new entity(IfcSchema::Type::IfcAnnotationFillAreaOccurrence, IfcAnnotationOccurrence_type); + IfcAnnotationSurface_type = new entity(IfcSchema::Type::IfcAnnotationSurface, IfcGeometricRepresentationItem_type); + IfcAxis1Placement_type = new entity(IfcSchema::Type::IfcAxis1Placement, IfcPlacement_type); + IfcAxis2Placement2D_type = new entity(IfcSchema::Type::IfcAxis2Placement2D, IfcPlacement_type); + IfcAxis2Placement3D_type = new entity(IfcSchema::Type::IfcAxis2Placement3D, IfcPlacement_type); + IfcBooleanResult_type = new entity(IfcSchema::Type::IfcBooleanResult, IfcGeometricRepresentationItem_type); + IfcBoundedSurface_type = new entity(IfcSchema::Type::IfcBoundedSurface, IfcSurface_type); + IfcBoundingBox_type = new entity(IfcSchema::Type::IfcBoundingBox, IfcGeometricRepresentationItem_type); + IfcBoxedHalfSpace_type = new entity(IfcSchema::Type::IfcBoxedHalfSpace, IfcHalfSpaceSolid_type); + IfcCShapeProfileDef_type = new entity(IfcSchema::Type::IfcCShapeProfileDef, IfcParameterizedProfileDef_type); + IfcCartesianPoint_type = new entity(IfcSchema::Type::IfcCartesianPoint, IfcPoint_type); + IfcCartesianTransformationOperator_type = new entity(IfcSchema::Type::IfcCartesianTransformationOperator, IfcGeometricRepresentationItem_type); + IfcCartesianTransformationOperator2D_type = new entity(IfcSchema::Type::IfcCartesianTransformationOperator2D, IfcCartesianTransformationOperator_type); + IfcCartesianTransformationOperator2DnonUniform_type = new entity(IfcSchema::Type::IfcCartesianTransformationOperator2DnonUniform, IfcCartesianTransformationOperator2D_type); + IfcCartesianTransformationOperator3D_type = new entity(IfcSchema::Type::IfcCartesianTransformationOperator3D, IfcCartesianTransformationOperator_type); + IfcCartesianTransformationOperator3DnonUniform_type = new entity(IfcSchema::Type::IfcCartesianTransformationOperator3DnonUniform, IfcCartesianTransformationOperator3D_type); + IfcCircleProfileDef_type = new entity(IfcSchema::Type::IfcCircleProfileDef, IfcParameterizedProfileDef_type); + IfcClosedShell_type = new entity(IfcSchema::Type::IfcClosedShell, IfcConnectedFaceSet_type); + IfcCompositeCurveSegment_type = new entity(IfcSchema::Type::IfcCompositeCurveSegment, IfcGeometricRepresentationItem_type); + IfcCraneRailAShapeProfileDef_type = new entity(IfcSchema::Type::IfcCraneRailAShapeProfileDef, IfcParameterizedProfileDef_type); + IfcCraneRailFShapeProfileDef_type = new entity(IfcSchema::Type::IfcCraneRailFShapeProfileDef, IfcParameterizedProfileDef_type); + IfcCsgPrimitive3D_type = new entity(IfcSchema::Type::IfcCsgPrimitive3D, IfcGeometricRepresentationItem_type); + IfcCsgSolid_type = new entity(IfcSchema::Type::IfcCsgSolid, IfcSolidModel_type); + IfcCurve_type = new entity(IfcSchema::Type::IfcCurve, IfcGeometricRepresentationItem_type); + IfcCurveBoundedPlane_type = new entity(IfcSchema::Type::IfcCurveBoundedPlane, IfcBoundedSurface_type); + IfcDefinedSymbol_type = new entity(IfcSchema::Type::IfcDefinedSymbol, IfcGeometricRepresentationItem_type); + IfcDimensionCurve_type = new entity(IfcSchema::Type::IfcDimensionCurve, IfcAnnotationCurveOccurrence_type); + IfcDimensionCurveTerminator_type = new entity(IfcSchema::Type::IfcDimensionCurveTerminator, IfcTerminatorSymbol_type); + IfcDirection_type = new entity(IfcSchema::Type::IfcDirection, IfcGeometricRepresentationItem_type); + IfcDoorLiningProperties_type = new entity(IfcSchema::Type::IfcDoorLiningProperties, IfcPropertySetDefinition_type); + IfcDoorPanelProperties_type = new entity(IfcSchema::Type::IfcDoorPanelProperties, IfcPropertySetDefinition_type); + IfcDoorStyle_type = new entity(IfcSchema::Type::IfcDoorStyle, IfcTypeProduct_type); + IfcDraughtingCallout_type = new entity(IfcSchema::Type::IfcDraughtingCallout, IfcGeometricRepresentationItem_type); + IfcDraughtingPreDefinedColour_type = new entity(IfcSchema::Type::IfcDraughtingPreDefinedColour, IfcPreDefinedColour_type); + IfcDraughtingPreDefinedCurveFont_type = new entity(IfcSchema::Type::IfcDraughtingPreDefinedCurveFont, IfcPreDefinedCurveFont_type); + IfcEdgeLoop_type = new entity(IfcSchema::Type::IfcEdgeLoop, IfcLoop_type); + IfcElementQuantity_type = new entity(IfcSchema::Type::IfcElementQuantity, IfcPropertySetDefinition_type); + IfcElementType_type = new entity(IfcSchema::Type::IfcElementType, IfcTypeProduct_type); + IfcElementarySurface_type = new entity(IfcSchema::Type::IfcElementarySurface, IfcSurface_type); + IfcEllipseProfileDef_type = new entity(IfcSchema::Type::IfcEllipseProfileDef, IfcParameterizedProfileDef_type); + IfcEnergyProperties_type = new entity(IfcSchema::Type::IfcEnergyProperties, IfcPropertySetDefinition_type); + IfcExtrudedAreaSolid_type = new entity(IfcSchema::Type::IfcExtrudedAreaSolid, IfcSweptAreaSolid_type); + IfcFaceBasedSurfaceModel_type = new entity(IfcSchema::Type::IfcFaceBasedSurfaceModel, IfcGeometricRepresentationItem_type); + IfcFillAreaStyleHatching_type = new entity(IfcSchema::Type::IfcFillAreaStyleHatching, IfcGeometricRepresentationItem_type); + IfcFillAreaStyleTileSymbolWithStyle_type = new entity(IfcSchema::Type::IfcFillAreaStyleTileSymbolWithStyle, IfcGeometricRepresentationItem_type); + IfcFillAreaStyleTiles_type = new entity(IfcSchema::Type::IfcFillAreaStyleTiles, IfcGeometricRepresentationItem_type); + IfcFluidFlowProperties_type = new entity(IfcSchema::Type::IfcFluidFlowProperties, IfcPropertySetDefinition_type); + IfcFurnishingElementType_type = new entity(IfcSchema::Type::IfcFurnishingElementType, IfcElementType_type); + IfcFurnitureType_type = new entity(IfcSchema::Type::IfcFurnitureType, IfcFurnishingElementType_type); + IfcGeometricCurveSet_type = new entity(IfcSchema::Type::IfcGeometricCurveSet, IfcGeometricSet_type); + IfcIShapeProfileDef_type = new entity(IfcSchema::Type::IfcIShapeProfileDef, IfcParameterizedProfileDef_type); + IfcLShapeProfileDef_type = new entity(IfcSchema::Type::IfcLShapeProfileDef, IfcParameterizedProfileDef_type); + IfcLine_type = new entity(IfcSchema::Type::IfcLine, IfcCurve_type); + IfcManifoldSolidBrep_type = new entity(IfcSchema::Type::IfcManifoldSolidBrep, IfcSolidModel_type); + IfcObject_type = new entity(IfcSchema::Type::IfcObject, IfcObjectDefinition_type); + IfcOffsetCurve2D_type = new entity(IfcSchema::Type::IfcOffsetCurve2D, IfcCurve_type); + IfcOffsetCurve3D_type = new entity(IfcSchema::Type::IfcOffsetCurve3D, IfcCurve_type); + IfcPermeableCoveringProperties_type = new entity(IfcSchema::Type::IfcPermeableCoveringProperties, IfcPropertySetDefinition_type); + IfcPlanarBox_type = new entity(IfcSchema::Type::IfcPlanarBox, IfcPlanarExtent_type); + IfcPlane_type = new entity(IfcSchema::Type::IfcPlane, IfcElementarySurface_type); + IfcProcess_type = new entity(IfcSchema::Type::IfcProcess, IfcObject_type); + IfcProduct_type = new entity(IfcSchema::Type::IfcProduct, IfcObject_type); + IfcProject_type = new entity(IfcSchema::Type::IfcProject, IfcObject_type); + IfcProjectionCurve_type = new entity(IfcSchema::Type::IfcProjectionCurve, IfcAnnotationCurveOccurrence_type); + IfcPropertySet_type = new entity(IfcSchema::Type::IfcPropertySet, IfcPropertySetDefinition_type); + IfcProxy_type = new entity(IfcSchema::Type::IfcProxy, IfcProduct_type); + IfcRectangleHollowProfileDef_type = new entity(IfcSchema::Type::IfcRectangleHollowProfileDef, IfcRectangleProfileDef_type); + IfcRectangularPyramid_type = new entity(IfcSchema::Type::IfcRectangularPyramid, IfcCsgPrimitive3D_type); + IfcRectangularTrimmedSurface_type = new entity(IfcSchema::Type::IfcRectangularTrimmedSurface, IfcBoundedSurface_type); + IfcRelAssigns_type = new entity(IfcSchema::Type::IfcRelAssigns, IfcRelationship_type); + IfcRelAssignsToActor_type = new entity(IfcSchema::Type::IfcRelAssignsToActor, IfcRelAssigns_type); + IfcRelAssignsToControl_type = new entity(IfcSchema::Type::IfcRelAssignsToControl, IfcRelAssigns_type); + IfcRelAssignsToGroup_type = new entity(IfcSchema::Type::IfcRelAssignsToGroup, IfcRelAssigns_type); + IfcRelAssignsToProcess_type = new entity(IfcSchema::Type::IfcRelAssignsToProcess, IfcRelAssigns_type); + IfcRelAssignsToProduct_type = new entity(IfcSchema::Type::IfcRelAssignsToProduct, IfcRelAssigns_type); + IfcRelAssignsToProjectOrder_type = new entity(IfcSchema::Type::IfcRelAssignsToProjectOrder, IfcRelAssignsToControl_type); + IfcRelAssignsToResource_type = new entity(IfcSchema::Type::IfcRelAssignsToResource, IfcRelAssigns_type); + IfcRelAssociates_type = new entity(IfcSchema::Type::IfcRelAssociates, IfcRelationship_type); + IfcRelAssociatesAppliedValue_type = new entity(IfcSchema::Type::IfcRelAssociatesAppliedValue, IfcRelAssociates_type); + IfcRelAssociatesApproval_type = new entity(IfcSchema::Type::IfcRelAssociatesApproval, IfcRelAssociates_type); + IfcRelAssociatesClassification_type = new entity(IfcSchema::Type::IfcRelAssociatesClassification, IfcRelAssociates_type); + IfcRelAssociatesConstraint_type = new entity(IfcSchema::Type::IfcRelAssociatesConstraint, IfcRelAssociates_type); + IfcRelAssociatesDocument_type = new entity(IfcSchema::Type::IfcRelAssociatesDocument, IfcRelAssociates_type); + IfcRelAssociatesLibrary_type = new entity(IfcSchema::Type::IfcRelAssociatesLibrary, IfcRelAssociates_type); + IfcRelAssociatesMaterial_type = new entity(IfcSchema::Type::IfcRelAssociatesMaterial, IfcRelAssociates_type); + IfcRelAssociatesProfileProperties_type = new entity(IfcSchema::Type::IfcRelAssociatesProfileProperties, IfcRelAssociates_type); + IfcRelConnects_type = new entity(IfcSchema::Type::IfcRelConnects, IfcRelationship_type); + IfcRelConnectsElements_type = new entity(IfcSchema::Type::IfcRelConnectsElements, IfcRelConnects_type); + IfcRelConnectsPathElements_type = new entity(IfcSchema::Type::IfcRelConnectsPathElements, IfcRelConnectsElements_type); + IfcRelConnectsPortToElement_type = new entity(IfcSchema::Type::IfcRelConnectsPortToElement, IfcRelConnects_type); + IfcRelConnectsPorts_type = new entity(IfcSchema::Type::IfcRelConnectsPorts, IfcRelConnects_type); + IfcRelConnectsStructuralActivity_type = new entity(IfcSchema::Type::IfcRelConnectsStructuralActivity, IfcRelConnects_type); + IfcRelConnectsStructuralElement_type = new entity(IfcSchema::Type::IfcRelConnectsStructuralElement, IfcRelConnects_type); + IfcRelConnectsStructuralMember_type = new entity(IfcSchema::Type::IfcRelConnectsStructuralMember, IfcRelConnects_type); + IfcRelConnectsWithEccentricity_type = new entity(IfcSchema::Type::IfcRelConnectsWithEccentricity, IfcRelConnectsStructuralMember_type); + IfcRelConnectsWithRealizingElements_type = new entity(IfcSchema::Type::IfcRelConnectsWithRealizingElements, IfcRelConnectsElements_type); + IfcRelContainedInSpatialStructure_type = new entity(IfcSchema::Type::IfcRelContainedInSpatialStructure, IfcRelConnects_type); + IfcRelCoversBldgElements_type = new entity(IfcSchema::Type::IfcRelCoversBldgElements, IfcRelConnects_type); + IfcRelCoversSpaces_type = new entity(IfcSchema::Type::IfcRelCoversSpaces, IfcRelConnects_type); + IfcRelDecomposes_type = new entity(IfcSchema::Type::IfcRelDecomposes, IfcRelationship_type); + IfcRelDefines_type = new entity(IfcSchema::Type::IfcRelDefines, IfcRelationship_type); + IfcRelDefinesByProperties_type = new entity(IfcSchema::Type::IfcRelDefinesByProperties, IfcRelDefines_type); + IfcRelDefinesByType_type = new entity(IfcSchema::Type::IfcRelDefinesByType, IfcRelDefines_type); + IfcRelFillsElement_type = new entity(IfcSchema::Type::IfcRelFillsElement, IfcRelConnects_type); + IfcRelFlowControlElements_type = new entity(IfcSchema::Type::IfcRelFlowControlElements, IfcRelConnects_type); + IfcRelInteractionRequirements_type = new entity(IfcSchema::Type::IfcRelInteractionRequirements, IfcRelConnects_type); + IfcRelNests_type = new entity(IfcSchema::Type::IfcRelNests, IfcRelDecomposes_type); + IfcRelOccupiesSpaces_type = new entity(IfcSchema::Type::IfcRelOccupiesSpaces, IfcRelAssignsToActor_type); + IfcRelOverridesProperties_type = new entity(IfcSchema::Type::IfcRelOverridesProperties, IfcRelDefinesByProperties_type); + IfcRelProjectsElement_type = new entity(IfcSchema::Type::IfcRelProjectsElement, IfcRelConnects_type); + IfcRelReferencedInSpatialStructure_type = new entity(IfcSchema::Type::IfcRelReferencedInSpatialStructure, IfcRelConnects_type); + IfcRelSchedulesCostItems_type = new entity(IfcSchema::Type::IfcRelSchedulesCostItems, IfcRelAssignsToControl_type); + IfcRelSequence_type = new entity(IfcSchema::Type::IfcRelSequence, IfcRelConnects_type); + IfcRelServicesBuildings_type = new entity(IfcSchema::Type::IfcRelServicesBuildings, IfcRelConnects_type); + IfcRelSpaceBoundary_type = new entity(IfcSchema::Type::IfcRelSpaceBoundary, IfcRelConnects_type); + IfcRelVoidsElement_type = new entity(IfcSchema::Type::IfcRelVoidsElement, IfcRelConnects_type); + IfcResource_type = new entity(IfcSchema::Type::IfcResource, IfcObject_type); + IfcRevolvedAreaSolid_type = new entity(IfcSchema::Type::IfcRevolvedAreaSolid, IfcSweptAreaSolid_type); + IfcRightCircularCone_type = new entity(IfcSchema::Type::IfcRightCircularCone, IfcCsgPrimitive3D_type); + IfcRightCircularCylinder_type = new entity(IfcSchema::Type::IfcRightCircularCylinder, IfcCsgPrimitive3D_type); + IfcSpatialStructureElement_type = new entity(IfcSchema::Type::IfcSpatialStructureElement, IfcProduct_type); + IfcSpatialStructureElementType_type = new entity(IfcSchema::Type::IfcSpatialStructureElementType, IfcElementType_type); + IfcSphere_type = new entity(IfcSchema::Type::IfcSphere, IfcCsgPrimitive3D_type); + IfcStructuralActivity_type = new entity(IfcSchema::Type::IfcStructuralActivity, IfcProduct_type); + IfcStructuralItem_type = new entity(IfcSchema::Type::IfcStructuralItem, IfcProduct_type); + IfcStructuralMember_type = new entity(IfcSchema::Type::IfcStructuralMember, IfcStructuralItem_type); + IfcStructuralReaction_type = new entity(IfcSchema::Type::IfcStructuralReaction, IfcStructuralActivity_type); + IfcStructuralSurfaceMember_type = new entity(IfcSchema::Type::IfcStructuralSurfaceMember, IfcStructuralMember_type); + IfcStructuralSurfaceMemberVarying_type = new entity(IfcSchema::Type::IfcStructuralSurfaceMemberVarying, IfcStructuralSurfaceMember_type); + IfcStructuredDimensionCallout_type = new entity(IfcSchema::Type::IfcStructuredDimensionCallout, IfcDraughtingCallout_type); + IfcSurfaceCurveSweptAreaSolid_type = new entity(IfcSchema::Type::IfcSurfaceCurveSweptAreaSolid, IfcSweptAreaSolid_type); + IfcSurfaceOfLinearExtrusion_type = new entity(IfcSchema::Type::IfcSurfaceOfLinearExtrusion, IfcSweptSurface_type); + IfcSurfaceOfRevolution_type = new entity(IfcSchema::Type::IfcSurfaceOfRevolution, IfcSweptSurface_type); + IfcSystemFurnitureElementType_type = new entity(IfcSchema::Type::IfcSystemFurnitureElementType, IfcFurnishingElementType_type); + IfcTask_type = new entity(IfcSchema::Type::IfcTask, IfcProcess_type); + IfcTransportElementType_type = new entity(IfcSchema::Type::IfcTransportElementType, IfcElementType_type); + IfcActor_type = new entity(IfcSchema::Type::IfcActor, IfcObject_type); + IfcAnnotation_type = new entity(IfcSchema::Type::IfcAnnotation, IfcProduct_type); + IfcAsymmetricIShapeProfileDef_type = new entity(IfcSchema::Type::IfcAsymmetricIShapeProfileDef, IfcIShapeProfileDef_type); + IfcBlock_type = new entity(IfcSchema::Type::IfcBlock, IfcCsgPrimitive3D_type); + IfcBooleanClippingResult_type = new entity(IfcSchema::Type::IfcBooleanClippingResult, IfcBooleanResult_type); + IfcBoundedCurve_type = new entity(IfcSchema::Type::IfcBoundedCurve, IfcCurve_type); + IfcBuilding_type = new entity(IfcSchema::Type::IfcBuilding, IfcSpatialStructureElement_type); + IfcBuildingElementType_type = new entity(IfcSchema::Type::IfcBuildingElementType, IfcElementType_type); + IfcBuildingStorey_type = new entity(IfcSchema::Type::IfcBuildingStorey, IfcSpatialStructureElement_type); + IfcCircleHollowProfileDef_type = new entity(IfcSchema::Type::IfcCircleHollowProfileDef, IfcCircleProfileDef_type); + IfcColumnType_type = new entity(IfcSchema::Type::IfcColumnType, IfcBuildingElementType_type); + IfcCompositeCurve_type = new entity(IfcSchema::Type::IfcCompositeCurve, IfcBoundedCurve_type); + IfcConic_type = new entity(IfcSchema::Type::IfcConic, IfcCurve_type); + IfcConstructionResource_type = new entity(IfcSchema::Type::IfcConstructionResource, IfcResource_type); + IfcControl_type = new entity(IfcSchema::Type::IfcControl, IfcObject_type); + IfcCostItem_type = new entity(IfcSchema::Type::IfcCostItem, IfcControl_type); + IfcCostSchedule_type = new entity(IfcSchema::Type::IfcCostSchedule, IfcControl_type); + IfcCoveringType_type = new entity(IfcSchema::Type::IfcCoveringType, IfcBuildingElementType_type); + IfcCrewResource_type = new entity(IfcSchema::Type::IfcCrewResource, IfcConstructionResource_type); + IfcCurtainWallType_type = new entity(IfcSchema::Type::IfcCurtainWallType, IfcBuildingElementType_type); + IfcDimensionCurveDirectedCallout_type = new entity(IfcSchema::Type::IfcDimensionCurveDirectedCallout, IfcDraughtingCallout_type); + IfcDistributionElementType_type = new entity(IfcSchema::Type::IfcDistributionElementType, IfcElementType_type); + IfcDistributionFlowElementType_type = new entity(IfcSchema::Type::IfcDistributionFlowElementType, IfcDistributionElementType_type); + IfcElectricalBaseProperties_type = new entity(IfcSchema::Type::IfcElectricalBaseProperties, IfcEnergyProperties_type); + IfcElement_type = new entity(IfcSchema::Type::IfcElement, IfcProduct_type); + IfcElementAssembly_type = new entity(IfcSchema::Type::IfcElementAssembly, IfcElement_type); + IfcElementComponent_type = new entity(IfcSchema::Type::IfcElementComponent, IfcElement_type); + IfcElementComponentType_type = new entity(IfcSchema::Type::IfcElementComponentType, IfcElementType_type); + IfcEllipse_type = new entity(IfcSchema::Type::IfcEllipse, IfcConic_type); + IfcEnergyConversionDeviceType_type = new entity(IfcSchema::Type::IfcEnergyConversionDeviceType, IfcDistributionFlowElementType_type); + IfcEquipmentElement_type = new entity(IfcSchema::Type::IfcEquipmentElement, IfcElement_type); + IfcEquipmentStandard_type = new entity(IfcSchema::Type::IfcEquipmentStandard, IfcControl_type); + IfcEvaporativeCoolerType_type = new entity(IfcSchema::Type::IfcEvaporativeCoolerType, IfcEnergyConversionDeviceType_type); + IfcEvaporatorType_type = new entity(IfcSchema::Type::IfcEvaporatorType, IfcEnergyConversionDeviceType_type); + IfcFacetedBrep_type = new entity(IfcSchema::Type::IfcFacetedBrep, IfcManifoldSolidBrep_type); + IfcFacetedBrepWithVoids_type = new entity(IfcSchema::Type::IfcFacetedBrepWithVoids, IfcManifoldSolidBrep_type); + IfcFastener_type = new entity(IfcSchema::Type::IfcFastener, IfcElementComponent_type); + IfcFastenerType_type = new entity(IfcSchema::Type::IfcFastenerType, IfcElementComponentType_type); + IfcFeatureElement_type = new entity(IfcSchema::Type::IfcFeatureElement, IfcElement_type); + IfcFeatureElementAddition_type = new entity(IfcSchema::Type::IfcFeatureElementAddition, IfcFeatureElement_type); + IfcFeatureElementSubtraction_type = new entity(IfcSchema::Type::IfcFeatureElementSubtraction, IfcFeatureElement_type); + IfcFlowControllerType_type = new entity(IfcSchema::Type::IfcFlowControllerType, IfcDistributionFlowElementType_type); + IfcFlowFittingType_type = new entity(IfcSchema::Type::IfcFlowFittingType, IfcDistributionFlowElementType_type); + IfcFlowMeterType_type = new entity(IfcSchema::Type::IfcFlowMeterType, IfcFlowControllerType_type); + IfcFlowMovingDeviceType_type = new entity(IfcSchema::Type::IfcFlowMovingDeviceType, IfcDistributionFlowElementType_type); + IfcFlowSegmentType_type = new entity(IfcSchema::Type::IfcFlowSegmentType, IfcDistributionFlowElementType_type); + IfcFlowStorageDeviceType_type = new entity(IfcSchema::Type::IfcFlowStorageDeviceType, IfcDistributionFlowElementType_type); + IfcFlowTerminalType_type = new entity(IfcSchema::Type::IfcFlowTerminalType, IfcDistributionFlowElementType_type); + IfcFlowTreatmentDeviceType_type = new entity(IfcSchema::Type::IfcFlowTreatmentDeviceType, IfcDistributionFlowElementType_type); + IfcFurnishingElement_type = new entity(IfcSchema::Type::IfcFurnishingElement, IfcElement_type); + IfcFurnitureStandard_type = new entity(IfcSchema::Type::IfcFurnitureStandard, IfcControl_type); + IfcGasTerminalType_type = new entity(IfcSchema::Type::IfcGasTerminalType, IfcFlowTerminalType_type); + IfcGrid_type = new entity(IfcSchema::Type::IfcGrid, IfcProduct_type); + IfcGroup_type = new entity(IfcSchema::Type::IfcGroup, IfcObject_type); + IfcHeatExchangerType_type = new entity(IfcSchema::Type::IfcHeatExchangerType, IfcEnergyConversionDeviceType_type); + IfcHumidifierType_type = new entity(IfcSchema::Type::IfcHumidifierType, IfcEnergyConversionDeviceType_type); + IfcInventory_type = new entity(IfcSchema::Type::IfcInventory, IfcGroup_type); + IfcJunctionBoxType_type = new entity(IfcSchema::Type::IfcJunctionBoxType, IfcFlowFittingType_type); + IfcLaborResource_type = new entity(IfcSchema::Type::IfcLaborResource, IfcConstructionResource_type); + IfcLampType_type = new entity(IfcSchema::Type::IfcLampType, IfcFlowTerminalType_type); + IfcLightFixtureType_type = new entity(IfcSchema::Type::IfcLightFixtureType, IfcFlowTerminalType_type); + IfcLinearDimension_type = new entity(IfcSchema::Type::IfcLinearDimension, IfcDimensionCurveDirectedCallout_type); + IfcMechanicalFastener_type = new entity(IfcSchema::Type::IfcMechanicalFastener, IfcFastener_type); + IfcMechanicalFastenerType_type = new entity(IfcSchema::Type::IfcMechanicalFastenerType, IfcFastenerType_type); + IfcMemberType_type = new entity(IfcSchema::Type::IfcMemberType, IfcBuildingElementType_type); + IfcMotorConnectionType_type = new entity(IfcSchema::Type::IfcMotorConnectionType, IfcEnergyConversionDeviceType_type); + IfcMove_type = new entity(IfcSchema::Type::IfcMove, IfcTask_type); + IfcOccupant_type = new entity(IfcSchema::Type::IfcOccupant, IfcActor_type); + IfcOpeningElement_type = new entity(IfcSchema::Type::IfcOpeningElement, IfcFeatureElementSubtraction_type); + IfcOrderAction_type = new entity(IfcSchema::Type::IfcOrderAction, IfcTask_type); + IfcOutletType_type = new entity(IfcSchema::Type::IfcOutletType, IfcFlowTerminalType_type); + IfcPerformanceHistory_type = new entity(IfcSchema::Type::IfcPerformanceHistory, IfcControl_type); + IfcPermit_type = new entity(IfcSchema::Type::IfcPermit, IfcControl_type); + IfcPipeFittingType_type = new entity(IfcSchema::Type::IfcPipeFittingType, IfcFlowFittingType_type); + IfcPipeSegmentType_type = new entity(IfcSchema::Type::IfcPipeSegmentType, IfcFlowSegmentType_type); + IfcPlateType_type = new entity(IfcSchema::Type::IfcPlateType, IfcBuildingElementType_type); + IfcPolyline_type = new entity(IfcSchema::Type::IfcPolyline, IfcBoundedCurve_type); + IfcPort_type = new entity(IfcSchema::Type::IfcPort, IfcProduct_type); + IfcProcedure_type = new entity(IfcSchema::Type::IfcProcedure, IfcProcess_type); + IfcProjectOrder_type = new entity(IfcSchema::Type::IfcProjectOrder, IfcControl_type); + IfcProjectOrderRecord_type = new entity(IfcSchema::Type::IfcProjectOrderRecord, IfcControl_type); + IfcProjectionElement_type = new entity(IfcSchema::Type::IfcProjectionElement, IfcFeatureElementAddition_type); + IfcProtectiveDeviceType_type = new entity(IfcSchema::Type::IfcProtectiveDeviceType, IfcFlowControllerType_type); + IfcPumpType_type = new entity(IfcSchema::Type::IfcPumpType, IfcFlowMovingDeviceType_type); + IfcRadiusDimension_type = new entity(IfcSchema::Type::IfcRadiusDimension, IfcDimensionCurveDirectedCallout_type); + IfcRailingType_type = new entity(IfcSchema::Type::IfcRailingType, IfcBuildingElementType_type); + IfcRampFlightType_type = new entity(IfcSchema::Type::IfcRampFlightType, IfcBuildingElementType_type); + IfcRelAggregates_type = new entity(IfcSchema::Type::IfcRelAggregates, IfcRelDecomposes_type); + IfcRelAssignsTasks_type = new entity(IfcSchema::Type::IfcRelAssignsTasks, IfcRelAssignsToControl_type); + IfcSanitaryTerminalType_type = new entity(IfcSchema::Type::IfcSanitaryTerminalType, IfcFlowTerminalType_type); + IfcScheduleTimeControl_type = new entity(IfcSchema::Type::IfcScheduleTimeControl, IfcControl_type); + IfcServiceLife_type = new entity(IfcSchema::Type::IfcServiceLife, IfcControl_type); + IfcSite_type = new entity(IfcSchema::Type::IfcSite, IfcSpatialStructureElement_type); + IfcSlabType_type = new entity(IfcSchema::Type::IfcSlabType, IfcBuildingElementType_type); + IfcSpace_type = new entity(IfcSchema::Type::IfcSpace, IfcSpatialStructureElement_type); + IfcSpaceHeaterType_type = new entity(IfcSchema::Type::IfcSpaceHeaterType, IfcEnergyConversionDeviceType_type); + IfcSpaceProgram_type = new entity(IfcSchema::Type::IfcSpaceProgram, IfcControl_type); + IfcSpaceType_type = new entity(IfcSchema::Type::IfcSpaceType, IfcSpatialStructureElementType_type); + IfcStackTerminalType_type = new entity(IfcSchema::Type::IfcStackTerminalType, IfcFlowTerminalType_type); + IfcStairFlightType_type = new entity(IfcSchema::Type::IfcStairFlightType, IfcBuildingElementType_type); + IfcStructuralAction_type = new entity(IfcSchema::Type::IfcStructuralAction, IfcStructuralActivity_type); + IfcStructuralConnection_type = new entity(IfcSchema::Type::IfcStructuralConnection, IfcStructuralItem_type); + IfcStructuralCurveConnection_type = new entity(IfcSchema::Type::IfcStructuralCurveConnection, IfcStructuralConnection_type); + IfcStructuralCurveMember_type = new entity(IfcSchema::Type::IfcStructuralCurveMember, IfcStructuralMember_type); + IfcStructuralCurveMemberVarying_type = new entity(IfcSchema::Type::IfcStructuralCurveMemberVarying, IfcStructuralCurveMember_type); + IfcStructuralLinearAction_type = new entity(IfcSchema::Type::IfcStructuralLinearAction, IfcStructuralAction_type); + IfcStructuralLinearActionVarying_type = new entity(IfcSchema::Type::IfcStructuralLinearActionVarying, IfcStructuralLinearAction_type); + IfcStructuralLoadGroup_type = new entity(IfcSchema::Type::IfcStructuralLoadGroup, IfcGroup_type); + IfcStructuralPlanarAction_type = new entity(IfcSchema::Type::IfcStructuralPlanarAction, IfcStructuralAction_type); + IfcStructuralPlanarActionVarying_type = new entity(IfcSchema::Type::IfcStructuralPlanarActionVarying, IfcStructuralPlanarAction_type); + IfcStructuralPointAction_type = new entity(IfcSchema::Type::IfcStructuralPointAction, IfcStructuralAction_type); + IfcStructuralPointConnection_type = new entity(IfcSchema::Type::IfcStructuralPointConnection, IfcStructuralConnection_type); + IfcStructuralPointReaction_type = new entity(IfcSchema::Type::IfcStructuralPointReaction, IfcStructuralReaction_type); + IfcStructuralResultGroup_type = new entity(IfcSchema::Type::IfcStructuralResultGroup, IfcGroup_type); + IfcStructuralSurfaceConnection_type = new entity(IfcSchema::Type::IfcStructuralSurfaceConnection, IfcStructuralConnection_type); + IfcSubContractResource_type = new entity(IfcSchema::Type::IfcSubContractResource, IfcConstructionResource_type); + IfcSwitchingDeviceType_type = new entity(IfcSchema::Type::IfcSwitchingDeviceType, IfcFlowControllerType_type); + IfcSystem_type = new entity(IfcSchema::Type::IfcSystem, IfcGroup_type); + IfcTankType_type = new entity(IfcSchema::Type::IfcTankType, IfcFlowStorageDeviceType_type); + IfcTimeSeriesSchedule_type = new entity(IfcSchema::Type::IfcTimeSeriesSchedule, IfcControl_type); + IfcTransformerType_type = new entity(IfcSchema::Type::IfcTransformerType, IfcEnergyConversionDeviceType_type); + IfcTransportElement_type = new entity(IfcSchema::Type::IfcTransportElement, IfcElement_type); + IfcTrimmedCurve_type = new entity(IfcSchema::Type::IfcTrimmedCurve, IfcBoundedCurve_type); + IfcTubeBundleType_type = new entity(IfcSchema::Type::IfcTubeBundleType, IfcEnergyConversionDeviceType_type); + IfcUnitaryEquipmentType_type = new entity(IfcSchema::Type::IfcUnitaryEquipmentType, IfcEnergyConversionDeviceType_type); + IfcValveType_type = new entity(IfcSchema::Type::IfcValveType, IfcFlowControllerType_type); + IfcVirtualElement_type = new entity(IfcSchema::Type::IfcVirtualElement, IfcElement_type); + IfcWallType_type = new entity(IfcSchema::Type::IfcWallType, IfcBuildingElementType_type); + IfcWasteTerminalType_type = new entity(IfcSchema::Type::IfcWasteTerminalType, IfcFlowTerminalType_type); + IfcWorkControl_type = new entity(IfcSchema::Type::IfcWorkControl, IfcControl_type); + IfcWorkPlan_type = new entity(IfcSchema::Type::IfcWorkPlan, IfcWorkControl_type); + IfcWorkSchedule_type = new entity(IfcSchema::Type::IfcWorkSchedule, IfcWorkControl_type); + IfcZone_type = new entity(IfcSchema::Type::IfcZone, IfcGroup_type); + Ifc2DCompositeCurve_type = new entity(IfcSchema::Type::Ifc2DCompositeCurve, IfcCompositeCurve_type); + IfcActionRequest_type = new entity(IfcSchema::Type::IfcActionRequest, IfcControl_type); + IfcAirTerminalBoxType_type = new entity(IfcSchema::Type::IfcAirTerminalBoxType, IfcFlowControllerType_type); + IfcAirTerminalType_type = new entity(IfcSchema::Type::IfcAirTerminalType, IfcFlowTerminalType_type); + IfcAirToAirHeatRecoveryType_type = new entity(IfcSchema::Type::IfcAirToAirHeatRecoveryType, IfcEnergyConversionDeviceType_type); + IfcAngularDimension_type = new entity(IfcSchema::Type::IfcAngularDimension, IfcDimensionCurveDirectedCallout_type); + IfcAsset_type = new entity(IfcSchema::Type::IfcAsset, IfcGroup_type); + IfcBSplineCurve_type = new entity(IfcSchema::Type::IfcBSplineCurve, IfcBoundedCurve_type); + IfcBeamType_type = new entity(IfcSchema::Type::IfcBeamType, IfcBuildingElementType_type); + IfcBezierCurve_type = new entity(IfcSchema::Type::IfcBezierCurve, IfcBSplineCurve_type); + IfcBoilerType_type = new entity(IfcSchema::Type::IfcBoilerType, IfcEnergyConversionDeviceType_type); + IfcBuildingElement_type = new entity(IfcSchema::Type::IfcBuildingElement, IfcElement_type); + IfcBuildingElementComponent_type = new entity(IfcSchema::Type::IfcBuildingElementComponent, IfcBuildingElement_type); + IfcBuildingElementPart_type = new entity(IfcSchema::Type::IfcBuildingElementPart, IfcBuildingElementComponent_type); + IfcBuildingElementProxy_type = new entity(IfcSchema::Type::IfcBuildingElementProxy, IfcBuildingElement_type); + IfcBuildingElementProxyType_type = new entity(IfcSchema::Type::IfcBuildingElementProxyType, IfcBuildingElementType_type); + IfcCableCarrierFittingType_type = new entity(IfcSchema::Type::IfcCableCarrierFittingType, IfcFlowFittingType_type); + IfcCableCarrierSegmentType_type = new entity(IfcSchema::Type::IfcCableCarrierSegmentType, IfcFlowSegmentType_type); + IfcCableSegmentType_type = new entity(IfcSchema::Type::IfcCableSegmentType, IfcFlowSegmentType_type); + IfcChillerType_type = new entity(IfcSchema::Type::IfcChillerType, IfcEnergyConversionDeviceType_type); + IfcCircle_type = new entity(IfcSchema::Type::IfcCircle, IfcConic_type); + IfcCoilType_type = new entity(IfcSchema::Type::IfcCoilType, IfcEnergyConversionDeviceType_type); + IfcColumn_type = new entity(IfcSchema::Type::IfcColumn, IfcBuildingElement_type); + IfcCompressorType_type = new entity(IfcSchema::Type::IfcCompressorType, IfcFlowMovingDeviceType_type); + IfcCondenserType_type = new entity(IfcSchema::Type::IfcCondenserType, IfcEnergyConversionDeviceType_type); + IfcCondition_type = new entity(IfcSchema::Type::IfcCondition, IfcGroup_type); + IfcConditionCriterion_type = new entity(IfcSchema::Type::IfcConditionCriterion, IfcControl_type); + IfcConstructionEquipmentResource_type = new entity(IfcSchema::Type::IfcConstructionEquipmentResource, IfcConstructionResource_type); + IfcConstructionMaterialResource_type = new entity(IfcSchema::Type::IfcConstructionMaterialResource, IfcConstructionResource_type); + IfcConstructionProductResource_type = new entity(IfcSchema::Type::IfcConstructionProductResource, IfcConstructionResource_type); + IfcCooledBeamType_type = new entity(IfcSchema::Type::IfcCooledBeamType, IfcEnergyConversionDeviceType_type); + IfcCoolingTowerType_type = new entity(IfcSchema::Type::IfcCoolingTowerType, IfcEnergyConversionDeviceType_type); + IfcCovering_type = new entity(IfcSchema::Type::IfcCovering, IfcBuildingElement_type); + IfcCurtainWall_type = new entity(IfcSchema::Type::IfcCurtainWall, IfcBuildingElement_type); + IfcDamperType_type = new entity(IfcSchema::Type::IfcDamperType, IfcFlowControllerType_type); + IfcDiameterDimension_type = new entity(IfcSchema::Type::IfcDiameterDimension, IfcDimensionCurveDirectedCallout_type); + IfcDiscreteAccessory_type = new entity(IfcSchema::Type::IfcDiscreteAccessory, IfcElementComponent_type); + IfcDiscreteAccessoryType_type = new entity(IfcSchema::Type::IfcDiscreteAccessoryType, IfcElementComponentType_type); + IfcDistributionChamberElementType_type = new entity(IfcSchema::Type::IfcDistributionChamberElementType, IfcDistributionFlowElementType_type); + IfcDistributionControlElementType_type = new entity(IfcSchema::Type::IfcDistributionControlElementType, IfcDistributionElementType_type); + IfcDistributionElement_type = new entity(IfcSchema::Type::IfcDistributionElement, IfcElement_type); + IfcDistributionFlowElement_type = new entity(IfcSchema::Type::IfcDistributionFlowElement, IfcDistributionElement_type); + IfcDistributionPort_type = new entity(IfcSchema::Type::IfcDistributionPort, IfcPort_type); + IfcDoor_type = new entity(IfcSchema::Type::IfcDoor, IfcBuildingElement_type); + IfcDuctFittingType_type = new entity(IfcSchema::Type::IfcDuctFittingType, IfcFlowFittingType_type); + IfcDuctSegmentType_type = new entity(IfcSchema::Type::IfcDuctSegmentType, IfcFlowSegmentType_type); + IfcDuctSilencerType_type = new entity(IfcSchema::Type::IfcDuctSilencerType, IfcFlowTreatmentDeviceType_type); + IfcEdgeFeature_type = new entity(IfcSchema::Type::IfcEdgeFeature, IfcFeatureElementSubtraction_type); + IfcElectricApplianceType_type = new entity(IfcSchema::Type::IfcElectricApplianceType, IfcFlowTerminalType_type); + IfcElectricFlowStorageDeviceType_type = new entity(IfcSchema::Type::IfcElectricFlowStorageDeviceType, IfcFlowStorageDeviceType_type); + IfcElectricGeneratorType_type = new entity(IfcSchema::Type::IfcElectricGeneratorType, IfcEnergyConversionDeviceType_type); + IfcElectricHeaterType_type = new entity(IfcSchema::Type::IfcElectricHeaterType, IfcFlowTerminalType_type); + IfcElectricMotorType_type = new entity(IfcSchema::Type::IfcElectricMotorType, IfcEnergyConversionDeviceType_type); + IfcElectricTimeControlType_type = new entity(IfcSchema::Type::IfcElectricTimeControlType, IfcFlowControllerType_type); + IfcElectricalCircuit_type = new entity(IfcSchema::Type::IfcElectricalCircuit, IfcSystem_type); + IfcElectricalElement_type = new entity(IfcSchema::Type::IfcElectricalElement, IfcElement_type); + IfcEnergyConversionDevice_type = new entity(IfcSchema::Type::IfcEnergyConversionDevice, IfcDistributionFlowElement_type); + IfcFanType_type = new entity(IfcSchema::Type::IfcFanType, IfcFlowMovingDeviceType_type); + IfcFilterType_type = new entity(IfcSchema::Type::IfcFilterType, IfcFlowTreatmentDeviceType_type); + IfcFireSuppressionTerminalType_type = new entity(IfcSchema::Type::IfcFireSuppressionTerminalType, IfcFlowTerminalType_type); + IfcFlowController_type = new entity(IfcSchema::Type::IfcFlowController, IfcDistributionFlowElement_type); + IfcFlowFitting_type = new entity(IfcSchema::Type::IfcFlowFitting, IfcDistributionFlowElement_type); + IfcFlowInstrumentType_type = new entity(IfcSchema::Type::IfcFlowInstrumentType, IfcDistributionControlElementType_type); + IfcFlowMovingDevice_type = new entity(IfcSchema::Type::IfcFlowMovingDevice, IfcDistributionFlowElement_type); + IfcFlowSegment_type = new entity(IfcSchema::Type::IfcFlowSegment, IfcDistributionFlowElement_type); + IfcFlowStorageDevice_type = new entity(IfcSchema::Type::IfcFlowStorageDevice, IfcDistributionFlowElement_type); + IfcFlowTerminal_type = new entity(IfcSchema::Type::IfcFlowTerminal, IfcDistributionFlowElement_type); + IfcFlowTreatmentDevice_type = new entity(IfcSchema::Type::IfcFlowTreatmentDevice, IfcDistributionFlowElement_type); + IfcFooting_type = new entity(IfcSchema::Type::IfcFooting, IfcBuildingElement_type); + IfcMember_type = new entity(IfcSchema::Type::IfcMember, IfcBuildingElement_type); + IfcPile_type = new entity(IfcSchema::Type::IfcPile, IfcBuildingElement_type); + IfcPlate_type = new entity(IfcSchema::Type::IfcPlate, IfcBuildingElement_type); + IfcRailing_type = new entity(IfcSchema::Type::IfcRailing, IfcBuildingElement_type); + IfcRamp_type = new entity(IfcSchema::Type::IfcRamp, IfcBuildingElement_type); + IfcRampFlight_type = new entity(IfcSchema::Type::IfcRampFlight, IfcBuildingElement_type); + IfcRationalBezierCurve_type = new entity(IfcSchema::Type::IfcRationalBezierCurve, IfcBezierCurve_type); + IfcReinforcingElement_type = new entity(IfcSchema::Type::IfcReinforcingElement, IfcBuildingElementComponent_type); + IfcReinforcingMesh_type = new entity(IfcSchema::Type::IfcReinforcingMesh, IfcReinforcingElement_type); + IfcRoof_type = new entity(IfcSchema::Type::IfcRoof, IfcBuildingElement_type); + IfcRoundedEdgeFeature_type = new entity(IfcSchema::Type::IfcRoundedEdgeFeature, IfcEdgeFeature_type); + IfcSensorType_type = new entity(IfcSchema::Type::IfcSensorType, IfcDistributionControlElementType_type); + IfcSlab_type = new entity(IfcSchema::Type::IfcSlab, IfcBuildingElement_type); + IfcStair_type = new entity(IfcSchema::Type::IfcStair, IfcBuildingElement_type); + IfcStairFlight_type = new entity(IfcSchema::Type::IfcStairFlight, IfcBuildingElement_type); + IfcStructuralAnalysisModel_type = new entity(IfcSchema::Type::IfcStructuralAnalysisModel, IfcSystem_type); + IfcTendon_type = new entity(IfcSchema::Type::IfcTendon, IfcReinforcingElement_type); + IfcTendonAnchor_type = new entity(IfcSchema::Type::IfcTendonAnchor, IfcReinforcingElement_type); + IfcVibrationIsolatorType_type = new entity(IfcSchema::Type::IfcVibrationIsolatorType, IfcDiscreteAccessoryType_type); + IfcWall_type = new entity(IfcSchema::Type::IfcWall, IfcBuildingElement_type); + IfcWallStandardCase_type = new entity(IfcSchema::Type::IfcWallStandardCase, IfcWall_type); + IfcWindow_type = new entity(IfcSchema::Type::IfcWindow, IfcBuildingElement_type); + IfcActuatorType_type = new entity(IfcSchema::Type::IfcActuatorType, IfcDistributionControlElementType_type); + IfcAlarmType_type = new entity(IfcSchema::Type::IfcAlarmType, IfcDistributionControlElementType_type); + IfcBeam_type = new entity(IfcSchema::Type::IfcBeam, IfcBuildingElement_type); + IfcChamferEdgeFeature_type = new entity(IfcSchema::Type::IfcChamferEdgeFeature, IfcEdgeFeature_type); + IfcControllerType_type = new entity(IfcSchema::Type::IfcControllerType, IfcDistributionControlElementType_type); + IfcDistributionChamberElement_type = new entity(IfcSchema::Type::IfcDistributionChamberElement, IfcDistributionFlowElement_type); + IfcDistributionControlElement_type = new entity(IfcSchema::Type::IfcDistributionControlElement, IfcDistributionElement_type); + IfcElectricDistributionPoint_type = new entity(IfcSchema::Type::IfcElectricDistributionPoint, IfcFlowController_type); + IfcReinforcingBar_type = new entity(IfcSchema::Type::IfcReinforcingBar, IfcReinforcingElement_type); { std::vector items; items.reserve(3); items.push_back(IfcOrganization_type); items.push_back(IfcPerson_type); items.push_back(IfcPersonAndOrganization_type); - IfcActorSelect_type = new select_type("IfcActorSelect", items); + IfcActorSelect_type = new select_type(IfcSchema::Type::IfcActorSelect, items); } - declaration* IfcAppliedValueSelect_type; { std::vector items; items.reserve(3); items.push_back(IfcMeasureWithUnit_type); items.push_back(IfcMonetaryMeasure_type); items.push_back(IfcRatioMeasure_type); - IfcAppliedValueSelect_type = new select_type("IfcAppliedValueSelect", items); + IfcAppliedValueSelect_type = new select_type(IfcSchema::Type::IfcAppliedValueSelect, items); } - declaration* IfcAxis2Placement_type; { std::vector items; items.reserve(2); items.push_back(IfcAxis2Placement2D_type); items.push_back(IfcAxis2Placement3D_type); - IfcAxis2Placement_type = new select_type("IfcAxis2Placement", items); + IfcAxis2Placement_type = new select_type(IfcSchema::Type::IfcAxis2Placement, items); } - declaration* IfcBooleanOperand_type; { std::vector items; items.reserve(4); items.push_back(IfcBooleanResult_type); items.push_back(IfcCsgPrimitive3D_type); items.push_back(IfcHalfSpaceSolid_type); items.push_back(IfcSolidModel_type); - IfcBooleanOperand_type = new select_type("IfcBooleanOperand", items); + IfcBooleanOperand_type = new select_type(IfcSchema::Type::IfcBooleanOperand, items); } - declaration* IfcCharacterStyleSelect_type; { std::vector items; items.reserve(1); items.push_back(IfcTextStyleForDefinedFont_type); - IfcCharacterStyleSelect_type = new select_type("IfcCharacterStyleSelect", items); + IfcCharacterStyleSelect_type = new select_type(IfcSchema::Type::IfcCharacterStyleSelect, items); } - declaration* IfcClassificationNotationSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcClassificationNotation_type); items.push_back(IfcClassificationReference_type); - IfcClassificationNotationSelect_type = new select_type("IfcClassificationNotationSelect", items); + IfcClassificationNotationSelect_type = new select_type(IfcSchema::Type::IfcClassificationNotationSelect, items); } - declaration* IfcColour_type; { std::vector items; items.reserve(2); items.push_back(IfcColourSpecification_type); items.push_back(IfcPreDefinedColour_type); - IfcColour_type = new select_type("IfcColour", items); + IfcColour_type = new select_type(IfcSchema::Type::IfcColour, items); } - declaration* IfcColourOrFactor_type; { std::vector items; items.reserve(2); items.push_back(IfcColourRgb_type); items.push_back(IfcNormalisedRatioMeasure_type); - IfcColourOrFactor_type = new select_type("IfcColourOrFactor", items); + IfcColourOrFactor_type = new select_type(IfcSchema::Type::IfcColourOrFactor, items); } - declaration* IfcConditionCriterionSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcLabel_type); items.push_back(IfcMeasureWithUnit_type); - IfcConditionCriterionSelect_type = new select_type("IfcConditionCriterionSelect", items); + IfcConditionCriterionSelect_type = new select_type(IfcSchema::Type::IfcConditionCriterionSelect, items); } - declaration* IfcCsgSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcBooleanResult_type); items.push_back(IfcCsgPrimitive3D_type); - IfcCsgSelect_type = new select_type("IfcCsgSelect", items); + IfcCsgSelect_type = new select_type(IfcSchema::Type::IfcCsgSelect, items); } - declaration* IfcCurveOrEdgeCurve_type; { std::vector items; items.reserve(2); items.push_back(IfcBoundedCurve_type); items.push_back(IfcEdgeCurve_type); - IfcCurveOrEdgeCurve_type = new select_type("IfcCurveOrEdgeCurve", items); + IfcCurveOrEdgeCurve_type = new select_type(IfcSchema::Type::IfcCurveOrEdgeCurve, items); } - declaration* IfcCurveStyleFontSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcCurveStyleFont_type); items.push_back(IfcPreDefinedCurveFont_type); - IfcCurveStyleFontSelect_type = new select_type("IfcCurveStyleFontSelect", items); + IfcCurveStyleFontSelect_type = new select_type(IfcSchema::Type::IfcCurveStyleFontSelect, items); } - declaration* IfcDateTimeSelect_type; { std::vector items; items.reserve(3); items.push_back(IfcCalendarDate_type); items.push_back(IfcDateAndTime_type); items.push_back(IfcLocalTime_type); - IfcDateTimeSelect_type = new select_type("IfcDateTimeSelect", items); + IfcDateTimeSelect_type = new select_type(IfcSchema::Type::IfcDateTimeSelect, items); } - declaration* IfcDefinedSymbolSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcExternallyDefinedSymbol_type); items.push_back(IfcPreDefinedSymbol_type); - IfcDefinedSymbolSelect_type = new select_type("IfcDefinedSymbolSelect", items); + IfcDefinedSymbolSelect_type = new select_type(IfcSchema::Type::IfcDefinedSymbolSelect, items); } - declaration* IfcDerivedMeasureValue_type; { std::vector items; items.reserve(68); items.push_back(IfcAbsorbedDoseMeasure_type); @@ -3102,75 +3904,65 @@ void populate() { items.push_back(IfcVolumetricFlowRateMeasure_type); items.push_back(IfcWarpingConstantMeasure_type); items.push_back(IfcWarpingMomentMeasure_type); - IfcDerivedMeasureValue_type = new select_type("IfcDerivedMeasureValue", items); + IfcDerivedMeasureValue_type = new select_type(IfcSchema::Type::IfcDerivedMeasureValue, items); } - declaration* IfcDocumentSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcDocumentInformation_type); items.push_back(IfcDocumentReference_type); - IfcDocumentSelect_type = new select_type("IfcDocumentSelect", items); + IfcDocumentSelect_type = new select_type(IfcSchema::Type::IfcDocumentSelect, items); } - declaration* IfcDraughtingCalloutElement_type; { std::vector items; items.reserve(3); items.push_back(IfcAnnotationCurveOccurrence_type); items.push_back(IfcAnnotationSymbolOccurrence_type); items.push_back(IfcAnnotationTextOccurrence_type); - IfcDraughtingCalloutElement_type = new select_type("IfcDraughtingCalloutElement", items); + IfcDraughtingCalloutElement_type = new select_type(IfcSchema::Type::IfcDraughtingCalloutElement, items); } - declaration* IfcFillAreaStyleTileShapeSelect_type; { std::vector items; items.reserve(1); items.push_back(IfcFillAreaStyleTileSymbolWithStyle_type); - IfcFillAreaStyleTileShapeSelect_type = new select_type("IfcFillAreaStyleTileShapeSelect", items); + IfcFillAreaStyleTileShapeSelect_type = new select_type(IfcSchema::Type::IfcFillAreaStyleTileShapeSelect, items); } - declaration* IfcFillStyleSelect_type; { std::vector items; items.reserve(4); items.push_back(IfcColour_type); items.push_back(IfcExternallyDefinedHatchStyle_type); items.push_back(IfcFillAreaStyleHatching_type); items.push_back(IfcFillAreaStyleTiles_type); - IfcFillStyleSelect_type = new select_type("IfcFillStyleSelect", items); + IfcFillStyleSelect_type = new select_type(IfcSchema::Type::IfcFillStyleSelect, items); } - declaration* IfcGeometricSetSelect_type; { std::vector items; items.reserve(3); items.push_back(IfcCurve_type); items.push_back(IfcPoint_type); items.push_back(IfcSurface_type); - IfcGeometricSetSelect_type = new select_type("IfcGeometricSetSelect", items); + IfcGeometricSetSelect_type = new select_type(IfcSchema::Type::IfcGeometricSetSelect, items); } - declaration* IfcHatchLineDistanceSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcOneDirectionRepeatFactor_type); items.push_back(IfcPositiveLengthMeasure_type); - IfcHatchLineDistanceSelect_type = new select_type("IfcHatchLineDistanceSelect", items); + IfcHatchLineDistanceSelect_type = new select_type(IfcSchema::Type::IfcHatchLineDistanceSelect, items); } - declaration* IfcLayeredItem_type; { std::vector items; items.reserve(2); items.push_back(IfcRepresentation_type); items.push_back(IfcRepresentationItem_type); - IfcLayeredItem_type = new select_type("IfcLayeredItem", items); + IfcLayeredItem_type = new select_type(IfcSchema::Type::IfcLayeredItem, items); } - declaration* IfcLibrarySelect_type; { std::vector items; items.reserve(2); items.push_back(IfcLibraryInformation_type); items.push_back(IfcLibraryReference_type); - IfcLibrarySelect_type = new select_type("IfcLibrarySelect", items); + IfcLibrarySelect_type = new select_type(IfcSchema::Type::IfcLibrarySelect, items); } - declaration* IfcLightDistributionDataSourceSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcExternalReference_type); items.push_back(IfcLightIntensityDistribution_type); - IfcLightDistributionDataSourceSelect_type = new select_type("IfcLightDistributionDataSourceSelect", items); + IfcLightDistributionDataSourceSelect_type = new select_type(IfcSchema::Type::IfcLightDistributionDataSourceSelect, items); } - declaration* IfcMaterialSelect_type; { std::vector items; items.reserve(5); items.push_back(IfcMaterial_type); @@ -3178,9 +3970,8 @@ void populate() { items.push_back(IfcMaterialLayerSet_type); items.push_back(IfcMaterialLayerSetUsage_type); items.push_back(IfcMaterialList_type); - IfcMaterialSelect_type = new select_type("IfcMaterialSelect", items); + IfcMaterialSelect_type = new select_type(IfcSchema::Type::IfcMaterialSelect, items); } - declaration* IfcMeasureValue_type; { std::vector items; items.reserve(22); items.push_back(IfcAmountOfSubstanceMeasure_type); @@ -3205,9 +3996,8 @@ void populate() { items.push_back(IfcThermodynamicTemperatureMeasure_type); items.push_back(IfcTimeMeasure_type); items.push_back(IfcVolumeMeasure_type); - IfcMeasureValue_type = new select_type("IfcMeasureValue", items); + IfcMeasureValue_type = new select_type(IfcSchema::Type::IfcMeasureValue, items); } - declaration* IfcMetricValueSelect_type; { std::vector items; items.reserve(6); items.push_back(IfcCostValue_type); @@ -3216,9 +4006,8 @@ void populate() { items.push_back(IfcTable_type); items.push_back(IfcText_type); items.push_back(IfcTimeSeries_type); - IfcMetricValueSelect_type = new select_type("IfcMetricValueSelect", items); + IfcMetricValueSelect_type = new select_type(IfcSchema::Type::IfcMetricValueSelect, items); } - declaration* IfcObjectReferenceSelect_type; { std::vector items; items.reserve(13); items.push_back(IfcAddress_type); @@ -3234,23 +4023,20 @@ void populate() { items.push_back(IfcPerson_type); items.push_back(IfcPersonAndOrganization_type); items.push_back(IfcTimeSeries_type); - IfcObjectReferenceSelect_type = new select_type("IfcObjectReferenceSelect", items); + IfcObjectReferenceSelect_type = new select_type(IfcSchema::Type::IfcObjectReferenceSelect, items); } - declaration* IfcOrientationSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcDirection_type); items.push_back(IfcPlaneAngleMeasure_type); - IfcOrientationSelect_type = new select_type("IfcOrientationSelect", items); + IfcOrientationSelect_type = new select_type(IfcSchema::Type::IfcOrientationSelect, items); } - declaration* IfcPointOrVertexPoint_type; { std::vector items; items.reserve(2); items.push_back(IfcPoint_type); items.push_back(IfcVertexPoint_type); - IfcPointOrVertexPoint_type = new select_type("IfcPointOrVertexPoint", items); + IfcPointOrVertexPoint_type = new select_type(IfcSchema::Type::IfcPointOrVertexPoint, items); } - declaration* IfcPresentationStyleSelect_type; { std::vector items; items.reserve(6); items.push_back(IfcCurveStyle_type); @@ -3259,16 +4045,14 @@ void populate() { items.push_back(IfcSurfaceStyle_type); items.push_back(IfcSymbolStyle_type); items.push_back(IfcTextStyle_type); - IfcPresentationStyleSelect_type = new select_type("IfcPresentationStyleSelect", items); + IfcPresentationStyleSelect_type = new select_type(IfcSchema::Type::IfcPresentationStyleSelect, items); } - declaration* IfcShell_type; { std::vector items; items.reserve(2); items.push_back(IfcClosedShell_type); items.push_back(IfcOpenShell_type); - IfcShell_type = new select_type("IfcShell", items); + IfcShell_type = new select_type(IfcSchema::Type::IfcShell, items); } - declaration* IfcSimpleValue_type; { std::vector items; items.reserve(7); items.push_back(IfcBoolean_type); @@ -3278,9 +4062,8 @@ void populate() { items.push_back(IfcLogical_type); items.push_back(IfcReal_type); items.push_back(IfcText_type); - IfcSimpleValue_type = new select_type("IfcSimpleValue", items); + IfcSimpleValue_type = new select_type(IfcSchema::Type::IfcSimpleValue, items); } - declaration* IfcSizeSelect_type; { std::vector items; items.reserve(6); items.push_back(IfcDescriptiveMeasure_type); @@ -3289,31 +4072,27 @@ void populate() { items.push_back(IfcPositiveLengthMeasure_type); items.push_back(IfcPositiveRatioMeasure_type); items.push_back(IfcRatioMeasure_type); - IfcSizeSelect_type = new select_type("IfcSizeSelect", items); + IfcSizeSelect_type = new select_type(IfcSchema::Type::IfcSizeSelect, items); } - declaration* IfcSpecularHighlightSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcSpecularExponent_type); items.push_back(IfcSpecularRoughness_type); - IfcSpecularHighlightSelect_type = new select_type("IfcSpecularHighlightSelect", items); + IfcSpecularHighlightSelect_type = new select_type(IfcSchema::Type::IfcSpecularHighlightSelect, items); } - declaration* IfcStructuralActivityAssignmentSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcElement_type); items.push_back(IfcStructuralItem_type); - IfcStructuralActivityAssignmentSelect_type = new select_type("IfcStructuralActivityAssignmentSelect", items); + IfcStructuralActivityAssignmentSelect_type = new select_type(IfcSchema::Type::IfcStructuralActivityAssignmentSelect, items); } - declaration* IfcSurfaceOrFaceSurface_type; { std::vector items; items.reserve(3); items.push_back(IfcFaceBasedSurfaceModel_type); items.push_back(IfcFaceSurface_type); items.push_back(IfcSurface_type); - IfcSurfaceOrFaceSurface_type = new select_type("IfcSurfaceOrFaceSurface", items); + IfcSurfaceOrFaceSurface_type = new select_type(IfcSchema::Type::IfcSurfaceOrFaceSurface, items); } - declaration* IfcSurfaceStyleElementSelect_type; { std::vector items; items.reserve(5); items.push_back(IfcExternallyDefinedSurfaceStyle_type); @@ -3321,64 +4100,56 @@ void populate() { items.push_back(IfcSurfaceStyleRefraction_type); items.push_back(IfcSurfaceStyleShading_type); items.push_back(IfcSurfaceStyleWithTextures_type); - IfcSurfaceStyleElementSelect_type = new select_type("IfcSurfaceStyleElementSelect", items); + IfcSurfaceStyleElementSelect_type = new select_type(IfcSchema::Type::IfcSurfaceStyleElementSelect, items); } - declaration* IfcSymbolStyleSelect_type; { std::vector items; items.reserve(1); items.push_back(IfcColour_type); - IfcSymbolStyleSelect_type = new select_type("IfcSymbolStyleSelect", items); + IfcSymbolStyleSelect_type = new select_type(IfcSchema::Type::IfcSymbolStyleSelect, items); } - declaration* IfcTextFontSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcExternallyDefinedTextFont_type); items.push_back(IfcPreDefinedTextFont_type); - IfcTextFontSelect_type = new select_type("IfcTextFontSelect", items); + IfcTextFontSelect_type = new select_type(IfcSchema::Type::IfcTextFontSelect, items); } - declaration* IfcTextStyleSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcTextStyleTextModel_type); items.push_back(IfcTextStyleWithBoxCharacteristics_type); - IfcTextStyleSelect_type = new select_type("IfcTextStyleSelect", items); + IfcTextStyleSelect_type = new select_type(IfcSchema::Type::IfcTextStyleSelect, items); } - declaration* IfcTrimmingSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcCartesianPoint_type); items.push_back(IfcParameterValue_type); - IfcTrimmingSelect_type = new select_type("IfcTrimmingSelect", items); + IfcTrimmingSelect_type = new select_type(IfcSchema::Type::IfcTrimmingSelect, items); } - declaration* IfcUnit_type; { std::vector items; items.reserve(3); items.push_back(IfcDerivedUnit_type); items.push_back(IfcMonetaryUnit_type); items.push_back(IfcNamedUnit_type); - IfcUnit_type = new select_type("IfcUnit", items); + IfcUnit_type = new select_type(IfcSchema::Type::IfcUnit, items); } - declaration* IfcValue_type; { std::vector items; items.reserve(3); items.push_back(IfcDerivedMeasureValue_type); items.push_back(IfcMeasureValue_type); items.push_back(IfcSimpleValue_type); - IfcValue_type = new select_type("IfcValue", items); + IfcValue_type = new select_type(IfcSchema::Type::IfcValue, items); } - declaration* IfcVectorOrDirection_type; { std::vector items; items.reserve(2); items.push_back(IfcDirection_type); items.push_back(IfcVector_type); - IfcVectorOrDirection_type = new select_type("IfcVectorOrDirection", items); + IfcVectorOrDirection_type = new select_type(IfcSchema::Type::IfcVectorOrDirection, items); } - declaration* IfcCurveFontOrScaledCurveFontSelect_type; { std::vector items; items.reserve(2); items.push_back(IfcCurveStyleFontAndScaling_type); items.push_back(IfcCurveStyleFontSelect_type); - IfcCurveFontOrScaledCurveFontSelect_type = new select_type("IfcCurveFontOrScaledCurveFontSelect", items); + IfcCurveFontOrScaledCurveFontSelect_type = new select_type(IfcSchema::Type::IfcCurveFontOrScaledCurveFontSelect, items); } { std::vector attributes; attributes.reserve(0); @@ -8618,6 +9389,995 @@ void populate() { derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); derived.push_back(false); IfcZone_type->set_attributes(attributes, derived); } + + std::vector declarations; declarations.reserve(980); + declarations.push_back(IfcAbsorbedDoseMeasure_type); + declarations.push_back(IfcAccelerationMeasure_type); + declarations.push_back(IfcAmountOfSubstanceMeasure_type); + declarations.push_back(IfcAngularVelocityMeasure_type); + declarations.push_back(IfcAreaMeasure_type); + declarations.push_back(IfcBoolean_type); + declarations.push_back(IfcComplexNumber_type); + declarations.push_back(IfcCompoundPlaneAngleMeasure_type); + declarations.push_back(IfcContextDependentMeasure_type); + declarations.push_back(IfcCountMeasure_type); + declarations.push_back(IfcCurvatureMeasure_type); + declarations.push_back(IfcDayInMonthNumber_type); + declarations.push_back(IfcDaylightSavingHour_type); + declarations.push_back(IfcDescriptiveMeasure_type); + declarations.push_back(IfcDimensionCount_type); + declarations.push_back(IfcDoseEquivalentMeasure_type); + declarations.push_back(IfcDynamicViscosityMeasure_type); + declarations.push_back(IfcElectricCapacitanceMeasure_type); + declarations.push_back(IfcElectricChargeMeasure_type); + declarations.push_back(IfcElectricConductanceMeasure_type); + declarations.push_back(IfcElectricCurrentMeasure_type); + declarations.push_back(IfcElectricResistanceMeasure_type); + declarations.push_back(IfcElectricVoltageMeasure_type); + declarations.push_back(IfcEnergyMeasure_type); + declarations.push_back(IfcFontStyle_type); + declarations.push_back(IfcFontVariant_type); + declarations.push_back(IfcFontWeight_type); + declarations.push_back(IfcForceMeasure_type); + declarations.push_back(IfcFrequencyMeasure_type); + declarations.push_back(IfcGloballyUniqueId_type); + declarations.push_back(IfcHeatFluxDensityMeasure_type); + declarations.push_back(IfcHeatingValueMeasure_type); + declarations.push_back(IfcHourInDay_type); + declarations.push_back(IfcIdentifier_type); + declarations.push_back(IfcIlluminanceMeasure_type); + declarations.push_back(IfcInductanceMeasure_type); + declarations.push_back(IfcInteger_type); + declarations.push_back(IfcIntegerCountRateMeasure_type); + declarations.push_back(IfcIonConcentrationMeasure_type); + declarations.push_back(IfcIsothermalMoistureCapacityMeasure_type); + declarations.push_back(IfcKinematicViscosityMeasure_type); + declarations.push_back(IfcLabel_type); + declarations.push_back(IfcLengthMeasure_type); + declarations.push_back(IfcLinearForceMeasure_type); + declarations.push_back(IfcLinearMomentMeasure_type); + declarations.push_back(IfcLinearStiffnessMeasure_type); + declarations.push_back(IfcLinearVelocityMeasure_type); + declarations.push_back(IfcLogical_type); + declarations.push_back(IfcLuminousFluxMeasure_type); + declarations.push_back(IfcLuminousIntensityDistributionMeasure_type); + declarations.push_back(IfcLuminousIntensityMeasure_type); + declarations.push_back(IfcMagneticFluxDensityMeasure_type); + declarations.push_back(IfcMagneticFluxMeasure_type); + declarations.push_back(IfcMassDensityMeasure_type); + declarations.push_back(IfcMassFlowRateMeasure_type); + declarations.push_back(IfcMassMeasure_type); + declarations.push_back(IfcMassPerLengthMeasure_type); + declarations.push_back(IfcMinuteInHour_type); + declarations.push_back(IfcModulusOfElasticityMeasure_type); + declarations.push_back(IfcModulusOfLinearSubgradeReactionMeasure_type); + declarations.push_back(IfcModulusOfRotationalSubgradeReactionMeasure_type); + declarations.push_back(IfcModulusOfSubgradeReactionMeasure_type); + declarations.push_back(IfcMoistureDiffusivityMeasure_type); + declarations.push_back(IfcMolecularWeightMeasure_type); + declarations.push_back(IfcMomentOfInertiaMeasure_type); + declarations.push_back(IfcMonetaryMeasure_type); + declarations.push_back(IfcMonthInYearNumber_type); + declarations.push_back(IfcNumericMeasure_type); + declarations.push_back(IfcPHMeasure_type); + declarations.push_back(IfcParameterValue_type); + declarations.push_back(IfcPlanarForceMeasure_type); + declarations.push_back(IfcPlaneAngleMeasure_type); + declarations.push_back(IfcPositiveLengthMeasure_type); + declarations.push_back(IfcPositivePlaneAngleMeasure_type); + declarations.push_back(IfcPowerMeasure_type); + declarations.push_back(IfcPresentableText_type); + declarations.push_back(IfcPressureMeasure_type); + declarations.push_back(IfcRadioActivityMeasure_type); + declarations.push_back(IfcRatioMeasure_type); + declarations.push_back(IfcReal_type); + declarations.push_back(IfcRotationalFrequencyMeasure_type); + declarations.push_back(IfcRotationalMassMeasure_type); + declarations.push_back(IfcRotationalStiffnessMeasure_type); + declarations.push_back(IfcSecondInMinute_type); + declarations.push_back(IfcSectionModulusMeasure_type); + declarations.push_back(IfcSectionalAreaIntegralMeasure_type); + declarations.push_back(IfcShearModulusMeasure_type); + declarations.push_back(IfcSolidAngleMeasure_type); + declarations.push_back(IfcSoundPowerMeasure_type); + declarations.push_back(IfcSoundPressureMeasure_type); + declarations.push_back(IfcSpecificHeatCapacityMeasure_type); + declarations.push_back(IfcSpecularExponent_type); + declarations.push_back(IfcSpecularRoughness_type); + declarations.push_back(IfcTemperatureGradientMeasure_type); + declarations.push_back(IfcText_type); + declarations.push_back(IfcTextAlignment_type); + declarations.push_back(IfcTextDecoration_type); + declarations.push_back(IfcTextFontName_type); + declarations.push_back(IfcTextTransformation_type); + declarations.push_back(IfcThermalAdmittanceMeasure_type); + declarations.push_back(IfcThermalConductivityMeasure_type); + declarations.push_back(IfcThermalExpansionCoefficientMeasure_type); + declarations.push_back(IfcThermalResistanceMeasure_type); + declarations.push_back(IfcThermalTransmittanceMeasure_type); + declarations.push_back(IfcThermodynamicTemperatureMeasure_type); + declarations.push_back(IfcTimeMeasure_type); + declarations.push_back(IfcTimeStamp_type); + declarations.push_back(IfcTorqueMeasure_type); + declarations.push_back(IfcVaporPermeabilityMeasure_type); + declarations.push_back(IfcVolumeMeasure_type); + declarations.push_back(IfcVolumetricFlowRateMeasure_type); + declarations.push_back(IfcWarpingConstantMeasure_type); + declarations.push_back(IfcWarpingMomentMeasure_type); + declarations.push_back(IfcYearNumber_type); + declarations.push_back(IfcBoxAlignment_type); + declarations.push_back(IfcNormalisedRatioMeasure_type); + declarations.push_back(IfcPositiveRatioMeasure_type); + declarations.push_back(IfcActionSourceTypeEnum_type); + declarations.push_back(IfcActionTypeEnum_type); + declarations.push_back(IfcActuatorTypeEnum_type); + declarations.push_back(IfcAddressTypeEnum_type); + declarations.push_back(IfcAheadOrBehind_type); + declarations.push_back(IfcAirTerminalBoxTypeEnum_type); + declarations.push_back(IfcAirTerminalTypeEnum_type); + declarations.push_back(IfcAirToAirHeatRecoveryTypeEnum_type); + declarations.push_back(IfcAlarmTypeEnum_type); + declarations.push_back(IfcAnalysisModelTypeEnum_type); + declarations.push_back(IfcAnalysisTheoryTypeEnum_type); + declarations.push_back(IfcArithmeticOperatorEnum_type); + declarations.push_back(IfcAssemblyPlaceEnum_type); + declarations.push_back(IfcBSplineCurveForm_type); + declarations.push_back(IfcBeamTypeEnum_type); + declarations.push_back(IfcBenchmarkEnum_type); + declarations.push_back(IfcBoilerTypeEnum_type); + declarations.push_back(IfcBooleanOperator_type); + declarations.push_back(IfcBuildingElementProxyTypeEnum_type); + declarations.push_back(IfcCableCarrierFittingTypeEnum_type); + declarations.push_back(IfcCableCarrierSegmentTypeEnum_type); + declarations.push_back(IfcCableSegmentTypeEnum_type); + declarations.push_back(IfcChangeActionEnum_type); + declarations.push_back(IfcChillerTypeEnum_type); + declarations.push_back(IfcCoilTypeEnum_type); + declarations.push_back(IfcColumnTypeEnum_type); + declarations.push_back(IfcCompressorTypeEnum_type); + declarations.push_back(IfcCondenserTypeEnum_type); + declarations.push_back(IfcConnectionTypeEnum_type); + declarations.push_back(IfcConstraintEnum_type); + declarations.push_back(IfcControllerTypeEnum_type); + declarations.push_back(IfcCooledBeamTypeEnum_type); + declarations.push_back(IfcCoolingTowerTypeEnum_type); + declarations.push_back(IfcCostScheduleTypeEnum_type); + declarations.push_back(IfcCoveringTypeEnum_type); + declarations.push_back(IfcCurrencyEnum_type); + declarations.push_back(IfcCurtainWallTypeEnum_type); + declarations.push_back(IfcDamperTypeEnum_type); + declarations.push_back(IfcDataOriginEnum_type); + declarations.push_back(IfcDerivedUnitEnum_type); + declarations.push_back(IfcDimensionExtentUsage_type); + declarations.push_back(IfcDirectionSenseEnum_type); + declarations.push_back(IfcDistributionChamberElementTypeEnum_type); + declarations.push_back(IfcDocumentConfidentialityEnum_type); + declarations.push_back(IfcDocumentStatusEnum_type); + declarations.push_back(IfcDoorPanelOperationEnum_type); + declarations.push_back(IfcDoorPanelPositionEnum_type); + declarations.push_back(IfcDoorStyleConstructionEnum_type); + declarations.push_back(IfcDoorStyleOperationEnum_type); + declarations.push_back(IfcDuctFittingTypeEnum_type); + declarations.push_back(IfcDuctSegmentTypeEnum_type); + declarations.push_back(IfcDuctSilencerTypeEnum_type); + declarations.push_back(IfcElectricApplianceTypeEnum_type); + declarations.push_back(IfcElectricCurrentEnum_type); + declarations.push_back(IfcElectricDistributionPointFunctionEnum_type); + declarations.push_back(IfcElectricFlowStorageDeviceTypeEnum_type); + declarations.push_back(IfcElectricGeneratorTypeEnum_type); + declarations.push_back(IfcElectricHeaterTypeEnum_type); + declarations.push_back(IfcElectricMotorTypeEnum_type); + declarations.push_back(IfcElectricTimeControlTypeEnum_type); + declarations.push_back(IfcElementAssemblyTypeEnum_type); + declarations.push_back(IfcElementCompositionEnum_type); + declarations.push_back(IfcEnergySequenceEnum_type); + declarations.push_back(IfcEnvironmentalImpactCategoryEnum_type); + declarations.push_back(IfcEvaporativeCoolerTypeEnum_type); + declarations.push_back(IfcEvaporatorTypeEnum_type); + declarations.push_back(IfcFanTypeEnum_type); + declarations.push_back(IfcFilterTypeEnum_type); + declarations.push_back(IfcFireSuppressionTerminalTypeEnum_type); + declarations.push_back(IfcFlowDirectionEnum_type); + declarations.push_back(IfcFlowInstrumentTypeEnum_type); + declarations.push_back(IfcFlowMeterTypeEnum_type); + declarations.push_back(IfcFootingTypeEnum_type); + declarations.push_back(IfcGasTerminalTypeEnum_type); + declarations.push_back(IfcGeometricProjectionEnum_type); + declarations.push_back(IfcGlobalOrLocalEnum_type); + declarations.push_back(IfcHeatExchangerTypeEnum_type); + declarations.push_back(IfcHumidifierTypeEnum_type); + declarations.push_back(IfcInternalOrExternalEnum_type); + declarations.push_back(IfcInventoryTypeEnum_type); + declarations.push_back(IfcJunctionBoxTypeEnum_type); + declarations.push_back(IfcLampTypeEnum_type); + declarations.push_back(IfcLayerSetDirectionEnum_type); + declarations.push_back(IfcLightDistributionCurveEnum_type); + declarations.push_back(IfcLightEmissionSourceEnum_type); + declarations.push_back(IfcLightFixtureTypeEnum_type); + declarations.push_back(IfcLoadGroupTypeEnum_type); + declarations.push_back(IfcLogicalOperatorEnum_type); + declarations.push_back(IfcMemberTypeEnum_type); + declarations.push_back(IfcMotorConnectionTypeEnum_type); + declarations.push_back(IfcNullStyle_type); + declarations.push_back(IfcObjectTypeEnum_type); + declarations.push_back(IfcObjectiveEnum_type); + declarations.push_back(IfcOccupantTypeEnum_type); + declarations.push_back(IfcOutletTypeEnum_type); + declarations.push_back(IfcPermeableCoveringOperationEnum_type); + declarations.push_back(IfcPhysicalOrVirtualEnum_type); + declarations.push_back(IfcPileConstructionEnum_type); + declarations.push_back(IfcPileTypeEnum_type); + declarations.push_back(IfcPipeFittingTypeEnum_type); + declarations.push_back(IfcPipeSegmentTypeEnum_type); + declarations.push_back(IfcPlateTypeEnum_type); + declarations.push_back(IfcProcedureTypeEnum_type); + declarations.push_back(IfcProfileTypeEnum_type); + declarations.push_back(IfcProjectOrderRecordTypeEnum_type); + declarations.push_back(IfcProjectOrderTypeEnum_type); + declarations.push_back(IfcProjectedOrTrueLengthEnum_type); + declarations.push_back(IfcPropertySourceEnum_type); + declarations.push_back(IfcProtectiveDeviceTypeEnum_type); + declarations.push_back(IfcPumpTypeEnum_type); + declarations.push_back(IfcRailingTypeEnum_type); + declarations.push_back(IfcRampFlightTypeEnum_type); + declarations.push_back(IfcRampTypeEnum_type); + declarations.push_back(IfcReflectanceMethodEnum_type); + declarations.push_back(IfcReinforcingBarRoleEnum_type); + declarations.push_back(IfcReinforcingBarSurfaceEnum_type); + declarations.push_back(IfcResourceConsumptionEnum_type); + declarations.push_back(IfcRibPlateDirectionEnum_type); + declarations.push_back(IfcRoleEnum_type); + declarations.push_back(IfcRoofTypeEnum_type); + declarations.push_back(IfcSIPrefix_type); + declarations.push_back(IfcSIUnitName_type); + declarations.push_back(IfcSanitaryTerminalTypeEnum_type); + declarations.push_back(IfcSectionTypeEnum_type); + declarations.push_back(IfcSensorTypeEnum_type); + declarations.push_back(IfcSequenceEnum_type); + declarations.push_back(IfcServiceLifeFactorTypeEnum_type); + declarations.push_back(IfcServiceLifeTypeEnum_type); + declarations.push_back(IfcSlabTypeEnum_type); + declarations.push_back(IfcSoundScaleEnum_type); + declarations.push_back(IfcSpaceHeaterTypeEnum_type); + declarations.push_back(IfcSpaceTypeEnum_type); + declarations.push_back(IfcStackTerminalTypeEnum_type); + declarations.push_back(IfcStairFlightTypeEnum_type); + declarations.push_back(IfcStairTypeEnum_type); + declarations.push_back(IfcStateEnum_type); + declarations.push_back(IfcStructuralCurveTypeEnum_type); + declarations.push_back(IfcStructuralSurfaceTypeEnum_type); + declarations.push_back(IfcSurfaceSide_type); + declarations.push_back(IfcSurfaceTextureEnum_type); + declarations.push_back(IfcSwitchingDeviceTypeEnum_type); + declarations.push_back(IfcTankTypeEnum_type); + declarations.push_back(IfcTendonTypeEnum_type); + declarations.push_back(IfcTextPath_type); + declarations.push_back(IfcThermalLoadSourceEnum_type); + declarations.push_back(IfcThermalLoadTypeEnum_type); + declarations.push_back(IfcTimeSeriesDataTypeEnum_type); + declarations.push_back(IfcTimeSeriesScheduleTypeEnum_type); + declarations.push_back(IfcTransformerTypeEnum_type); + declarations.push_back(IfcTransitionCode_type); + declarations.push_back(IfcTransportElementTypeEnum_type); + declarations.push_back(IfcTrimmingPreference_type); + declarations.push_back(IfcTubeBundleTypeEnum_type); + declarations.push_back(IfcUnitEnum_type); + declarations.push_back(IfcUnitaryEquipmentTypeEnum_type); + declarations.push_back(IfcValveTypeEnum_type); + declarations.push_back(IfcVibrationIsolatorTypeEnum_type); + declarations.push_back(IfcWallTypeEnum_type); + declarations.push_back(IfcWasteTerminalTypeEnum_type); + declarations.push_back(IfcWindowPanelOperationEnum_type); + declarations.push_back(IfcWindowPanelPositionEnum_type); + declarations.push_back(IfcWindowStyleConstructionEnum_type); + declarations.push_back(IfcWindowStyleOperationEnum_type); + declarations.push_back(IfcWorkControlTypeEnum_type); + declarations.push_back(IfcActorRole_type); + declarations.push_back(IfcAddress_type); + declarations.push_back(IfcApplication_type); + declarations.push_back(IfcAppliedValue_type); + declarations.push_back(IfcAppliedValueRelationship_type); + declarations.push_back(IfcApproval_type); + declarations.push_back(IfcApprovalActorRelationship_type); + declarations.push_back(IfcApprovalPropertyRelationship_type); + declarations.push_back(IfcApprovalRelationship_type); + declarations.push_back(IfcBoundaryCondition_type); + declarations.push_back(IfcBoundaryEdgeCondition_type); + declarations.push_back(IfcBoundaryFaceCondition_type); + declarations.push_back(IfcBoundaryNodeCondition_type); + declarations.push_back(IfcBoundaryNodeConditionWarping_type); + declarations.push_back(IfcCalendarDate_type); + declarations.push_back(IfcClassification_type); + declarations.push_back(IfcClassificationItem_type); + declarations.push_back(IfcClassificationItemRelationship_type); + declarations.push_back(IfcClassificationNotation_type); + declarations.push_back(IfcClassificationNotationFacet_type); + declarations.push_back(IfcColourSpecification_type); + declarations.push_back(IfcConnectionGeometry_type); + declarations.push_back(IfcConnectionPointGeometry_type); + declarations.push_back(IfcConnectionPortGeometry_type); + declarations.push_back(IfcConnectionSurfaceGeometry_type); + declarations.push_back(IfcConstraint_type); + declarations.push_back(IfcConstraintAggregationRelationship_type); + declarations.push_back(IfcConstraintClassificationRelationship_type); + declarations.push_back(IfcConstraintRelationship_type); + declarations.push_back(IfcCoordinatedUniversalTimeOffset_type); + declarations.push_back(IfcCostValue_type); + declarations.push_back(IfcCurrencyRelationship_type); + declarations.push_back(IfcCurveStyleFont_type); + declarations.push_back(IfcCurveStyleFontAndScaling_type); + declarations.push_back(IfcCurveStyleFontPattern_type); + declarations.push_back(IfcDateAndTime_type); + declarations.push_back(IfcDerivedUnit_type); + declarations.push_back(IfcDerivedUnitElement_type); + declarations.push_back(IfcDimensionalExponents_type); + declarations.push_back(IfcDocumentElectronicFormat_type); + declarations.push_back(IfcDocumentInformation_type); + declarations.push_back(IfcDocumentInformationRelationship_type); + declarations.push_back(IfcDraughtingCalloutRelationship_type); + declarations.push_back(IfcEnvironmentalImpactValue_type); + declarations.push_back(IfcExternalReference_type); + declarations.push_back(IfcExternallyDefinedHatchStyle_type); + declarations.push_back(IfcExternallyDefinedSurfaceStyle_type); + declarations.push_back(IfcExternallyDefinedSymbol_type); + declarations.push_back(IfcExternallyDefinedTextFont_type); + declarations.push_back(IfcGridAxis_type); + declarations.push_back(IfcIrregularTimeSeriesValue_type); + declarations.push_back(IfcLibraryInformation_type); + declarations.push_back(IfcLibraryReference_type); + declarations.push_back(IfcLightDistributionData_type); + declarations.push_back(IfcLightIntensityDistribution_type); + declarations.push_back(IfcLocalTime_type); + declarations.push_back(IfcMaterial_type); + declarations.push_back(IfcMaterialClassificationRelationship_type); + declarations.push_back(IfcMaterialLayer_type); + declarations.push_back(IfcMaterialLayerSet_type); + declarations.push_back(IfcMaterialLayerSetUsage_type); + declarations.push_back(IfcMaterialList_type); + declarations.push_back(IfcMaterialProperties_type); + declarations.push_back(IfcMeasureWithUnit_type); + declarations.push_back(IfcMechanicalMaterialProperties_type); + declarations.push_back(IfcMechanicalSteelMaterialProperties_type); + declarations.push_back(IfcMetric_type); + declarations.push_back(IfcMonetaryUnit_type); + declarations.push_back(IfcNamedUnit_type); + declarations.push_back(IfcObjectPlacement_type); + declarations.push_back(IfcObjective_type); + declarations.push_back(IfcOpticalMaterialProperties_type); + declarations.push_back(IfcOrganization_type); + declarations.push_back(IfcOrganizationRelationship_type); + declarations.push_back(IfcOwnerHistory_type); + declarations.push_back(IfcPerson_type); + declarations.push_back(IfcPersonAndOrganization_type); + declarations.push_back(IfcPhysicalQuantity_type); + declarations.push_back(IfcPhysicalSimpleQuantity_type); + declarations.push_back(IfcPostalAddress_type); + declarations.push_back(IfcPreDefinedItem_type); + declarations.push_back(IfcPreDefinedSymbol_type); + declarations.push_back(IfcPreDefinedTerminatorSymbol_type); + declarations.push_back(IfcPreDefinedTextFont_type); + declarations.push_back(IfcPresentationLayerAssignment_type); + declarations.push_back(IfcPresentationLayerWithStyle_type); + declarations.push_back(IfcPresentationStyle_type); + declarations.push_back(IfcPresentationStyleAssignment_type); + declarations.push_back(IfcProductRepresentation_type); + declarations.push_back(IfcProductsOfCombustionProperties_type); + declarations.push_back(IfcProfileDef_type); + declarations.push_back(IfcProfileProperties_type); + declarations.push_back(IfcProperty_type); + declarations.push_back(IfcPropertyConstraintRelationship_type); + declarations.push_back(IfcPropertyDependencyRelationship_type); + declarations.push_back(IfcPropertyEnumeration_type); + declarations.push_back(IfcQuantityArea_type); + declarations.push_back(IfcQuantityCount_type); + declarations.push_back(IfcQuantityLength_type); + declarations.push_back(IfcQuantityTime_type); + declarations.push_back(IfcQuantityVolume_type); + declarations.push_back(IfcQuantityWeight_type); + declarations.push_back(IfcReferencesValueDocument_type); + declarations.push_back(IfcReinforcementBarProperties_type); + declarations.push_back(IfcRelaxation_type); + declarations.push_back(IfcRepresentation_type); + declarations.push_back(IfcRepresentationContext_type); + declarations.push_back(IfcRepresentationItem_type); + declarations.push_back(IfcRepresentationMap_type); + declarations.push_back(IfcRibPlateProfileProperties_type); + declarations.push_back(IfcRoot_type); + declarations.push_back(IfcSIUnit_type); + declarations.push_back(IfcSectionProperties_type); + declarations.push_back(IfcSectionReinforcementProperties_type); + declarations.push_back(IfcShapeAspect_type); + declarations.push_back(IfcShapeModel_type); + declarations.push_back(IfcShapeRepresentation_type); + declarations.push_back(IfcSimpleProperty_type); + declarations.push_back(IfcStructuralConnectionCondition_type); + declarations.push_back(IfcStructuralLoad_type); + declarations.push_back(IfcStructuralLoadStatic_type); + declarations.push_back(IfcStructuralLoadTemperature_type); + declarations.push_back(IfcStyleModel_type); + declarations.push_back(IfcStyledItem_type); + declarations.push_back(IfcStyledRepresentation_type); + declarations.push_back(IfcSurfaceStyle_type); + declarations.push_back(IfcSurfaceStyleLighting_type); + declarations.push_back(IfcSurfaceStyleRefraction_type); + declarations.push_back(IfcSurfaceStyleShading_type); + declarations.push_back(IfcSurfaceStyleWithTextures_type); + declarations.push_back(IfcSurfaceTexture_type); + declarations.push_back(IfcSymbolStyle_type); + declarations.push_back(IfcTable_type); + declarations.push_back(IfcTableRow_type); + declarations.push_back(IfcTelecomAddress_type); + declarations.push_back(IfcTextStyle_type); + declarations.push_back(IfcTextStyleFontModel_type); + declarations.push_back(IfcTextStyleForDefinedFont_type); + declarations.push_back(IfcTextStyleTextModel_type); + declarations.push_back(IfcTextStyleWithBoxCharacteristics_type); + declarations.push_back(IfcTextureCoordinate_type); + declarations.push_back(IfcTextureCoordinateGenerator_type); + declarations.push_back(IfcTextureMap_type); + declarations.push_back(IfcTextureVertex_type); + declarations.push_back(IfcThermalMaterialProperties_type); + declarations.push_back(IfcTimeSeries_type); + declarations.push_back(IfcTimeSeriesReferenceRelationship_type); + declarations.push_back(IfcTimeSeriesValue_type); + declarations.push_back(IfcTopologicalRepresentationItem_type); + declarations.push_back(IfcTopologyRepresentation_type); + declarations.push_back(IfcUnitAssignment_type); + declarations.push_back(IfcVertex_type); + declarations.push_back(IfcVertexBasedTextureMap_type); + declarations.push_back(IfcVertexPoint_type); + declarations.push_back(IfcVirtualGridIntersection_type); + declarations.push_back(IfcWaterProperties_type); + declarations.push_back(IfcAnnotationOccurrence_type); + declarations.push_back(IfcAnnotationSurfaceOccurrence_type); + declarations.push_back(IfcAnnotationSymbolOccurrence_type); + declarations.push_back(IfcAnnotationTextOccurrence_type); + declarations.push_back(IfcArbitraryClosedProfileDef_type); + declarations.push_back(IfcArbitraryOpenProfileDef_type); + declarations.push_back(IfcArbitraryProfileDefWithVoids_type); + declarations.push_back(IfcBlobTexture_type); + declarations.push_back(IfcCenterLineProfileDef_type); + declarations.push_back(IfcClassificationReference_type); + declarations.push_back(IfcColourRgb_type); + declarations.push_back(IfcComplexProperty_type); + declarations.push_back(IfcCompositeProfileDef_type); + declarations.push_back(IfcConnectedFaceSet_type); + declarations.push_back(IfcConnectionCurveGeometry_type); + declarations.push_back(IfcConnectionPointEccentricity_type); + declarations.push_back(IfcContextDependentUnit_type); + declarations.push_back(IfcConversionBasedUnit_type); + declarations.push_back(IfcCurveStyle_type); + declarations.push_back(IfcDerivedProfileDef_type); + declarations.push_back(IfcDimensionCalloutRelationship_type); + declarations.push_back(IfcDimensionPair_type); + declarations.push_back(IfcDocumentReference_type); + declarations.push_back(IfcDraughtingPreDefinedTextFont_type); + declarations.push_back(IfcEdge_type); + declarations.push_back(IfcEdgeCurve_type); + declarations.push_back(IfcExtendedMaterialProperties_type); + declarations.push_back(IfcFace_type); + declarations.push_back(IfcFaceBound_type); + declarations.push_back(IfcFaceOuterBound_type); + declarations.push_back(IfcFaceSurface_type); + declarations.push_back(IfcFailureConnectionCondition_type); + declarations.push_back(IfcFillAreaStyle_type); + declarations.push_back(IfcFuelProperties_type); + declarations.push_back(IfcGeneralMaterialProperties_type); + declarations.push_back(IfcGeneralProfileProperties_type); + declarations.push_back(IfcGeometricRepresentationContext_type); + declarations.push_back(IfcGeometricRepresentationItem_type); + declarations.push_back(IfcGeometricRepresentationSubContext_type); + declarations.push_back(IfcGeometricSet_type); + declarations.push_back(IfcGridPlacement_type); + declarations.push_back(IfcHalfSpaceSolid_type); + declarations.push_back(IfcHygroscopicMaterialProperties_type); + declarations.push_back(IfcImageTexture_type); + declarations.push_back(IfcIrregularTimeSeries_type); + declarations.push_back(IfcLightSource_type); + declarations.push_back(IfcLightSourceAmbient_type); + declarations.push_back(IfcLightSourceDirectional_type); + declarations.push_back(IfcLightSourceGoniometric_type); + declarations.push_back(IfcLightSourcePositional_type); + declarations.push_back(IfcLightSourceSpot_type); + declarations.push_back(IfcLocalPlacement_type); + declarations.push_back(IfcLoop_type); + declarations.push_back(IfcMappedItem_type); + declarations.push_back(IfcMaterialDefinitionRepresentation_type); + declarations.push_back(IfcMechanicalConcreteMaterialProperties_type); + declarations.push_back(IfcObjectDefinition_type); + declarations.push_back(IfcOneDirectionRepeatFactor_type); + declarations.push_back(IfcOpenShell_type); + declarations.push_back(IfcOrientedEdge_type); + declarations.push_back(IfcParameterizedProfileDef_type); + declarations.push_back(IfcPath_type); + declarations.push_back(IfcPhysicalComplexQuantity_type); + declarations.push_back(IfcPixelTexture_type); + declarations.push_back(IfcPlacement_type); + declarations.push_back(IfcPlanarExtent_type); + declarations.push_back(IfcPoint_type); + declarations.push_back(IfcPointOnCurve_type); + declarations.push_back(IfcPointOnSurface_type); + declarations.push_back(IfcPolyLoop_type); + declarations.push_back(IfcPolygonalBoundedHalfSpace_type); + declarations.push_back(IfcPreDefinedColour_type); + declarations.push_back(IfcPreDefinedCurveFont_type); + declarations.push_back(IfcPreDefinedDimensionSymbol_type); + declarations.push_back(IfcPreDefinedPointMarkerSymbol_type); + declarations.push_back(IfcProductDefinitionShape_type); + declarations.push_back(IfcPropertyBoundedValue_type); + declarations.push_back(IfcPropertyDefinition_type); + declarations.push_back(IfcPropertyEnumeratedValue_type); + declarations.push_back(IfcPropertyListValue_type); + declarations.push_back(IfcPropertyReferenceValue_type); + declarations.push_back(IfcPropertySetDefinition_type); + declarations.push_back(IfcPropertySingleValue_type); + declarations.push_back(IfcPropertyTableValue_type); + declarations.push_back(IfcRectangleProfileDef_type); + declarations.push_back(IfcRegularTimeSeries_type); + declarations.push_back(IfcReinforcementDefinitionProperties_type); + declarations.push_back(IfcRelationship_type); + declarations.push_back(IfcRoundedRectangleProfileDef_type); + declarations.push_back(IfcSectionedSpine_type); + declarations.push_back(IfcServiceLifeFactor_type); + declarations.push_back(IfcShellBasedSurfaceModel_type); + declarations.push_back(IfcSlippageConnectionCondition_type); + declarations.push_back(IfcSolidModel_type); + declarations.push_back(IfcSoundProperties_type); + declarations.push_back(IfcSoundValue_type); + declarations.push_back(IfcSpaceThermalLoadProperties_type); + declarations.push_back(IfcStructuralLoadLinearForce_type); + declarations.push_back(IfcStructuralLoadPlanarForce_type); + declarations.push_back(IfcStructuralLoadSingleDisplacement_type); + declarations.push_back(IfcStructuralLoadSingleDisplacementDistortion_type); + declarations.push_back(IfcStructuralLoadSingleForce_type); + declarations.push_back(IfcStructuralLoadSingleForceWarping_type); + declarations.push_back(IfcStructuralProfileProperties_type); + declarations.push_back(IfcStructuralSteelProfileProperties_type); + declarations.push_back(IfcSubedge_type); + declarations.push_back(IfcSurface_type); + declarations.push_back(IfcSurfaceStyleRendering_type); + declarations.push_back(IfcSweptAreaSolid_type); + declarations.push_back(IfcSweptDiskSolid_type); + declarations.push_back(IfcSweptSurface_type); + declarations.push_back(IfcTShapeProfileDef_type); + declarations.push_back(IfcTerminatorSymbol_type); + declarations.push_back(IfcTextLiteral_type); + declarations.push_back(IfcTextLiteralWithExtent_type); + declarations.push_back(IfcTrapeziumProfileDef_type); + declarations.push_back(IfcTwoDirectionRepeatFactor_type); + declarations.push_back(IfcTypeObject_type); + declarations.push_back(IfcTypeProduct_type); + declarations.push_back(IfcUShapeProfileDef_type); + declarations.push_back(IfcVector_type); + declarations.push_back(IfcVertexLoop_type); + declarations.push_back(IfcWindowLiningProperties_type); + declarations.push_back(IfcWindowPanelProperties_type); + declarations.push_back(IfcWindowStyle_type); + declarations.push_back(IfcZShapeProfileDef_type); + declarations.push_back(IfcAnnotationCurveOccurrence_type); + declarations.push_back(IfcAnnotationFillArea_type); + declarations.push_back(IfcAnnotationFillAreaOccurrence_type); + declarations.push_back(IfcAnnotationSurface_type); + declarations.push_back(IfcAxis1Placement_type); + declarations.push_back(IfcAxis2Placement2D_type); + declarations.push_back(IfcAxis2Placement3D_type); + declarations.push_back(IfcBooleanResult_type); + declarations.push_back(IfcBoundedSurface_type); + declarations.push_back(IfcBoundingBox_type); + declarations.push_back(IfcBoxedHalfSpace_type); + declarations.push_back(IfcCShapeProfileDef_type); + declarations.push_back(IfcCartesianPoint_type); + declarations.push_back(IfcCartesianTransformationOperator_type); + declarations.push_back(IfcCartesianTransformationOperator2D_type); + declarations.push_back(IfcCartesianTransformationOperator2DnonUniform_type); + declarations.push_back(IfcCartesianTransformationOperator3D_type); + declarations.push_back(IfcCartesianTransformationOperator3DnonUniform_type); + declarations.push_back(IfcCircleProfileDef_type); + declarations.push_back(IfcClosedShell_type); + declarations.push_back(IfcCompositeCurveSegment_type); + declarations.push_back(IfcCraneRailAShapeProfileDef_type); + declarations.push_back(IfcCraneRailFShapeProfileDef_type); + declarations.push_back(IfcCsgPrimitive3D_type); + declarations.push_back(IfcCsgSolid_type); + declarations.push_back(IfcCurve_type); + declarations.push_back(IfcCurveBoundedPlane_type); + declarations.push_back(IfcDefinedSymbol_type); + declarations.push_back(IfcDimensionCurve_type); + declarations.push_back(IfcDimensionCurveTerminator_type); + declarations.push_back(IfcDirection_type); + declarations.push_back(IfcDoorLiningProperties_type); + declarations.push_back(IfcDoorPanelProperties_type); + declarations.push_back(IfcDoorStyle_type); + declarations.push_back(IfcDraughtingCallout_type); + declarations.push_back(IfcDraughtingPreDefinedColour_type); + declarations.push_back(IfcDraughtingPreDefinedCurveFont_type); + declarations.push_back(IfcEdgeLoop_type); + declarations.push_back(IfcElementQuantity_type); + declarations.push_back(IfcElementType_type); + declarations.push_back(IfcElementarySurface_type); + declarations.push_back(IfcEllipseProfileDef_type); + declarations.push_back(IfcEnergyProperties_type); + declarations.push_back(IfcExtrudedAreaSolid_type); + declarations.push_back(IfcFaceBasedSurfaceModel_type); + declarations.push_back(IfcFillAreaStyleHatching_type); + declarations.push_back(IfcFillAreaStyleTileSymbolWithStyle_type); + declarations.push_back(IfcFillAreaStyleTiles_type); + declarations.push_back(IfcFluidFlowProperties_type); + declarations.push_back(IfcFurnishingElementType_type); + declarations.push_back(IfcFurnitureType_type); + declarations.push_back(IfcGeometricCurveSet_type); + declarations.push_back(IfcIShapeProfileDef_type); + declarations.push_back(IfcLShapeProfileDef_type); + declarations.push_back(IfcLine_type); + declarations.push_back(IfcManifoldSolidBrep_type); + declarations.push_back(IfcObject_type); + declarations.push_back(IfcOffsetCurve2D_type); + declarations.push_back(IfcOffsetCurve3D_type); + declarations.push_back(IfcPermeableCoveringProperties_type); + declarations.push_back(IfcPlanarBox_type); + declarations.push_back(IfcPlane_type); + declarations.push_back(IfcProcess_type); + declarations.push_back(IfcProduct_type); + declarations.push_back(IfcProject_type); + declarations.push_back(IfcProjectionCurve_type); + declarations.push_back(IfcPropertySet_type); + declarations.push_back(IfcProxy_type); + declarations.push_back(IfcRectangleHollowProfileDef_type); + declarations.push_back(IfcRectangularPyramid_type); + declarations.push_back(IfcRectangularTrimmedSurface_type); + declarations.push_back(IfcRelAssigns_type); + declarations.push_back(IfcRelAssignsToActor_type); + declarations.push_back(IfcRelAssignsToControl_type); + declarations.push_back(IfcRelAssignsToGroup_type); + declarations.push_back(IfcRelAssignsToProcess_type); + declarations.push_back(IfcRelAssignsToProduct_type); + declarations.push_back(IfcRelAssignsToProjectOrder_type); + declarations.push_back(IfcRelAssignsToResource_type); + declarations.push_back(IfcRelAssociates_type); + declarations.push_back(IfcRelAssociatesAppliedValue_type); + declarations.push_back(IfcRelAssociatesApproval_type); + declarations.push_back(IfcRelAssociatesClassification_type); + declarations.push_back(IfcRelAssociatesConstraint_type); + declarations.push_back(IfcRelAssociatesDocument_type); + declarations.push_back(IfcRelAssociatesLibrary_type); + declarations.push_back(IfcRelAssociatesMaterial_type); + declarations.push_back(IfcRelAssociatesProfileProperties_type); + declarations.push_back(IfcRelConnects_type); + declarations.push_back(IfcRelConnectsElements_type); + declarations.push_back(IfcRelConnectsPathElements_type); + declarations.push_back(IfcRelConnectsPortToElement_type); + declarations.push_back(IfcRelConnectsPorts_type); + declarations.push_back(IfcRelConnectsStructuralActivity_type); + declarations.push_back(IfcRelConnectsStructuralElement_type); + declarations.push_back(IfcRelConnectsStructuralMember_type); + declarations.push_back(IfcRelConnectsWithEccentricity_type); + declarations.push_back(IfcRelConnectsWithRealizingElements_type); + declarations.push_back(IfcRelContainedInSpatialStructure_type); + declarations.push_back(IfcRelCoversBldgElements_type); + declarations.push_back(IfcRelCoversSpaces_type); + declarations.push_back(IfcRelDecomposes_type); + declarations.push_back(IfcRelDefines_type); + declarations.push_back(IfcRelDefinesByProperties_type); + declarations.push_back(IfcRelDefinesByType_type); + declarations.push_back(IfcRelFillsElement_type); + declarations.push_back(IfcRelFlowControlElements_type); + declarations.push_back(IfcRelInteractionRequirements_type); + declarations.push_back(IfcRelNests_type); + declarations.push_back(IfcRelOccupiesSpaces_type); + declarations.push_back(IfcRelOverridesProperties_type); + declarations.push_back(IfcRelProjectsElement_type); + declarations.push_back(IfcRelReferencedInSpatialStructure_type); + declarations.push_back(IfcRelSchedulesCostItems_type); + declarations.push_back(IfcRelSequence_type); + declarations.push_back(IfcRelServicesBuildings_type); + declarations.push_back(IfcRelSpaceBoundary_type); + declarations.push_back(IfcRelVoidsElement_type); + declarations.push_back(IfcResource_type); + declarations.push_back(IfcRevolvedAreaSolid_type); + declarations.push_back(IfcRightCircularCone_type); + declarations.push_back(IfcRightCircularCylinder_type); + declarations.push_back(IfcSpatialStructureElement_type); + declarations.push_back(IfcSpatialStructureElementType_type); + declarations.push_back(IfcSphere_type); + declarations.push_back(IfcStructuralActivity_type); + declarations.push_back(IfcStructuralItem_type); + declarations.push_back(IfcStructuralMember_type); + declarations.push_back(IfcStructuralReaction_type); + declarations.push_back(IfcStructuralSurfaceMember_type); + declarations.push_back(IfcStructuralSurfaceMemberVarying_type); + declarations.push_back(IfcStructuredDimensionCallout_type); + declarations.push_back(IfcSurfaceCurveSweptAreaSolid_type); + declarations.push_back(IfcSurfaceOfLinearExtrusion_type); + declarations.push_back(IfcSurfaceOfRevolution_type); + declarations.push_back(IfcSystemFurnitureElementType_type); + declarations.push_back(IfcTask_type); + declarations.push_back(IfcTransportElementType_type); + declarations.push_back(IfcActor_type); + declarations.push_back(IfcAnnotation_type); + declarations.push_back(IfcAsymmetricIShapeProfileDef_type); + declarations.push_back(IfcBlock_type); + declarations.push_back(IfcBooleanClippingResult_type); + declarations.push_back(IfcBoundedCurve_type); + declarations.push_back(IfcBuilding_type); + declarations.push_back(IfcBuildingElementType_type); + declarations.push_back(IfcBuildingStorey_type); + declarations.push_back(IfcCircleHollowProfileDef_type); + declarations.push_back(IfcColumnType_type); + declarations.push_back(IfcCompositeCurve_type); + declarations.push_back(IfcConic_type); + declarations.push_back(IfcConstructionResource_type); + declarations.push_back(IfcControl_type); + declarations.push_back(IfcCostItem_type); + declarations.push_back(IfcCostSchedule_type); + declarations.push_back(IfcCoveringType_type); + declarations.push_back(IfcCrewResource_type); + declarations.push_back(IfcCurtainWallType_type); + declarations.push_back(IfcDimensionCurveDirectedCallout_type); + declarations.push_back(IfcDistributionElementType_type); + declarations.push_back(IfcDistributionFlowElementType_type); + declarations.push_back(IfcElectricalBaseProperties_type); + declarations.push_back(IfcElement_type); + declarations.push_back(IfcElementAssembly_type); + declarations.push_back(IfcElementComponent_type); + declarations.push_back(IfcElementComponentType_type); + declarations.push_back(IfcEllipse_type); + declarations.push_back(IfcEnergyConversionDeviceType_type); + declarations.push_back(IfcEquipmentElement_type); + declarations.push_back(IfcEquipmentStandard_type); + declarations.push_back(IfcEvaporativeCoolerType_type); + declarations.push_back(IfcEvaporatorType_type); + declarations.push_back(IfcFacetedBrep_type); + declarations.push_back(IfcFacetedBrepWithVoids_type); + declarations.push_back(IfcFastener_type); + declarations.push_back(IfcFastenerType_type); + declarations.push_back(IfcFeatureElement_type); + declarations.push_back(IfcFeatureElementAddition_type); + declarations.push_back(IfcFeatureElementSubtraction_type); + declarations.push_back(IfcFlowControllerType_type); + declarations.push_back(IfcFlowFittingType_type); + declarations.push_back(IfcFlowMeterType_type); + declarations.push_back(IfcFlowMovingDeviceType_type); + declarations.push_back(IfcFlowSegmentType_type); + declarations.push_back(IfcFlowStorageDeviceType_type); + declarations.push_back(IfcFlowTerminalType_type); + declarations.push_back(IfcFlowTreatmentDeviceType_type); + declarations.push_back(IfcFurnishingElement_type); + declarations.push_back(IfcFurnitureStandard_type); + declarations.push_back(IfcGasTerminalType_type); + declarations.push_back(IfcGrid_type); + declarations.push_back(IfcGroup_type); + declarations.push_back(IfcHeatExchangerType_type); + declarations.push_back(IfcHumidifierType_type); + declarations.push_back(IfcInventory_type); + declarations.push_back(IfcJunctionBoxType_type); + declarations.push_back(IfcLaborResource_type); + declarations.push_back(IfcLampType_type); + declarations.push_back(IfcLightFixtureType_type); + declarations.push_back(IfcLinearDimension_type); + declarations.push_back(IfcMechanicalFastener_type); + declarations.push_back(IfcMechanicalFastenerType_type); + declarations.push_back(IfcMemberType_type); + declarations.push_back(IfcMotorConnectionType_type); + declarations.push_back(IfcMove_type); + declarations.push_back(IfcOccupant_type); + declarations.push_back(IfcOpeningElement_type); + declarations.push_back(IfcOrderAction_type); + declarations.push_back(IfcOutletType_type); + declarations.push_back(IfcPerformanceHistory_type); + declarations.push_back(IfcPermit_type); + declarations.push_back(IfcPipeFittingType_type); + declarations.push_back(IfcPipeSegmentType_type); + declarations.push_back(IfcPlateType_type); + declarations.push_back(IfcPolyline_type); + declarations.push_back(IfcPort_type); + declarations.push_back(IfcProcedure_type); + declarations.push_back(IfcProjectOrder_type); + declarations.push_back(IfcProjectOrderRecord_type); + declarations.push_back(IfcProjectionElement_type); + declarations.push_back(IfcProtectiveDeviceType_type); + declarations.push_back(IfcPumpType_type); + declarations.push_back(IfcRadiusDimension_type); + declarations.push_back(IfcRailingType_type); + declarations.push_back(IfcRampFlightType_type); + declarations.push_back(IfcRelAggregates_type); + declarations.push_back(IfcRelAssignsTasks_type); + declarations.push_back(IfcSanitaryTerminalType_type); + declarations.push_back(IfcScheduleTimeControl_type); + declarations.push_back(IfcServiceLife_type); + declarations.push_back(IfcSite_type); + declarations.push_back(IfcSlabType_type); + declarations.push_back(IfcSpace_type); + declarations.push_back(IfcSpaceHeaterType_type); + declarations.push_back(IfcSpaceProgram_type); + declarations.push_back(IfcSpaceType_type); + declarations.push_back(IfcStackTerminalType_type); + declarations.push_back(IfcStairFlightType_type); + declarations.push_back(IfcStructuralAction_type); + declarations.push_back(IfcStructuralConnection_type); + declarations.push_back(IfcStructuralCurveConnection_type); + declarations.push_back(IfcStructuralCurveMember_type); + declarations.push_back(IfcStructuralCurveMemberVarying_type); + declarations.push_back(IfcStructuralLinearAction_type); + declarations.push_back(IfcStructuralLinearActionVarying_type); + declarations.push_back(IfcStructuralLoadGroup_type); + declarations.push_back(IfcStructuralPlanarAction_type); + declarations.push_back(IfcStructuralPlanarActionVarying_type); + declarations.push_back(IfcStructuralPointAction_type); + declarations.push_back(IfcStructuralPointConnection_type); + declarations.push_back(IfcStructuralPointReaction_type); + declarations.push_back(IfcStructuralResultGroup_type); + declarations.push_back(IfcStructuralSurfaceConnection_type); + declarations.push_back(IfcSubContractResource_type); + declarations.push_back(IfcSwitchingDeviceType_type); + declarations.push_back(IfcSystem_type); + declarations.push_back(IfcTankType_type); + declarations.push_back(IfcTimeSeriesSchedule_type); + declarations.push_back(IfcTransformerType_type); + declarations.push_back(IfcTransportElement_type); + declarations.push_back(IfcTrimmedCurve_type); + declarations.push_back(IfcTubeBundleType_type); + declarations.push_back(IfcUnitaryEquipmentType_type); + declarations.push_back(IfcValveType_type); + declarations.push_back(IfcVirtualElement_type); + declarations.push_back(IfcWallType_type); + declarations.push_back(IfcWasteTerminalType_type); + declarations.push_back(IfcWorkControl_type); + declarations.push_back(IfcWorkPlan_type); + declarations.push_back(IfcWorkSchedule_type); + declarations.push_back(IfcZone_type); + declarations.push_back(Ifc2DCompositeCurve_type); + declarations.push_back(IfcActionRequest_type); + declarations.push_back(IfcAirTerminalBoxType_type); + declarations.push_back(IfcAirTerminalType_type); + declarations.push_back(IfcAirToAirHeatRecoveryType_type); + declarations.push_back(IfcAngularDimension_type); + declarations.push_back(IfcAsset_type); + declarations.push_back(IfcBSplineCurve_type); + declarations.push_back(IfcBeamType_type); + declarations.push_back(IfcBezierCurve_type); + declarations.push_back(IfcBoilerType_type); + declarations.push_back(IfcBuildingElement_type); + declarations.push_back(IfcBuildingElementComponent_type); + declarations.push_back(IfcBuildingElementPart_type); + declarations.push_back(IfcBuildingElementProxy_type); + declarations.push_back(IfcBuildingElementProxyType_type); + declarations.push_back(IfcCableCarrierFittingType_type); + declarations.push_back(IfcCableCarrierSegmentType_type); + declarations.push_back(IfcCableSegmentType_type); + declarations.push_back(IfcChillerType_type); + declarations.push_back(IfcCircle_type); + declarations.push_back(IfcCoilType_type); + declarations.push_back(IfcColumn_type); + declarations.push_back(IfcCompressorType_type); + declarations.push_back(IfcCondenserType_type); + declarations.push_back(IfcCondition_type); + declarations.push_back(IfcConditionCriterion_type); + declarations.push_back(IfcConstructionEquipmentResource_type); + declarations.push_back(IfcConstructionMaterialResource_type); + declarations.push_back(IfcConstructionProductResource_type); + declarations.push_back(IfcCooledBeamType_type); + declarations.push_back(IfcCoolingTowerType_type); + declarations.push_back(IfcCovering_type); + declarations.push_back(IfcCurtainWall_type); + declarations.push_back(IfcDamperType_type); + declarations.push_back(IfcDiameterDimension_type); + declarations.push_back(IfcDiscreteAccessory_type); + declarations.push_back(IfcDiscreteAccessoryType_type); + declarations.push_back(IfcDistributionChamberElementType_type); + declarations.push_back(IfcDistributionControlElementType_type); + declarations.push_back(IfcDistributionElement_type); + declarations.push_back(IfcDistributionFlowElement_type); + declarations.push_back(IfcDistributionPort_type); + declarations.push_back(IfcDoor_type); + declarations.push_back(IfcDuctFittingType_type); + declarations.push_back(IfcDuctSegmentType_type); + declarations.push_back(IfcDuctSilencerType_type); + declarations.push_back(IfcEdgeFeature_type); + declarations.push_back(IfcElectricApplianceType_type); + declarations.push_back(IfcElectricFlowStorageDeviceType_type); + declarations.push_back(IfcElectricGeneratorType_type); + declarations.push_back(IfcElectricHeaterType_type); + declarations.push_back(IfcElectricMotorType_type); + declarations.push_back(IfcElectricTimeControlType_type); + declarations.push_back(IfcElectricalCircuit_type); + declarations.push_back(IfcElectricalElement_type); + declarations.push_back(IfcEnergyConversionDevice_type); + declarations.push_back(IfcFanType_type); + declarations.push_back(IfcFilterType_type); + declarations.push_back(IfcFireSuppressionTerminalType_type); + declarations.push_back(IfcFlowController_type); + declarations.push_back(IfcFlowFitting_type); + declarations.push_back(IfcFlowInstrumentType_type); + declarations.push_back(IfcFlowMovingDevice_type); + declarations.push_back(IfcFlowSegment_type); + declarations.push_back(IfcFlowStorageDevice_type); + declarations.push_back(IfcFlowTerminal_type); + declarations.push_back(IfcFlowTreatmentDevice_type); + declarations.push_back(IfcFooting_type); + declarations.push_back(IfcMember_type); + declarations.push_back(IfcPile_type); + declarations.push_back(IfcPlate_type); + declarations.push_back(IfcRailing_type); + declarations.push_back(IfcRamp_type); + declarations.push_back(IfcRampFlight_type); + declarations.push_back(IfcRationalBezierCurve_type); + declarations.push_back(IfcReinforcingElement_type); + declarations.push_back(IfcReinforcingMesh_type); + declarations.push_back(IfcRoof_type); + declarations.push_back(IfcRoundedEdgeFeature_type); + declarations.push_back(IfcSensorType_type); + declarations.push_back(IfcSlab_type); + declarations.push_back(IfcStair_type); + declarations.push_back(IfcStairFlight_type); + declarations.push_back(IfcStructuralAnalysisModel_type); + declarations.push_back(IfcTendon_type); + declarations.push_back(IfcTendonAnchor_type); + declarations.push_back(IfcVibrationIsolatorType_type); + declarations.push_back(IfcWall_type); + declarations.push_back(IfcWallStandardCase_type); + declarations.push_back(IfcWindow_type); + declarations.push_back(IfcActuatorType_type); + declarations.push_back(IfcAlarmType_type); + declarations.push_back(IfcBeam_type); + declarations.push_back(IfcChamferEdgeFeature_type); + declarations.push_back(IfcControllerType_type); + declarations.push_back(IfcDistributionChamberElement_type); + declarations.push_back(IfcDistributionControlElement_type); + declarations.push_back(IfcElectricDistributionPoint_type); + declarations.push_back(IfcReinforcingBar_type); + declarations.push_back(IfcActorSelect_type); + declarations.push_back(IfcAppliedValueSelect_type); + declarations.push_back(IfcAxis2Placement_type); + declarations.push_back(IfcBooleanOperand_type); + declarations.push_back(IfcCharacterStyleSelect_type); + declarations.push_back(IfcClassificationNotationSelect_type); + declarations.push_back(IfcColour_type); + declarations.push_back(IfcColourOrFactor_type); + declarations.push_back(IfcConditionCriterionSelect_type); + declarations.push_back(IfcCsgSelect_type); + declarations.push_back(IfcCurveOrEdgeCurve_type); + declarations.push_back(IfcCurveStyleFontSelect_type); + declarations.push_back(IfcDateTimeSelect_type); + declarations.push_back(IfcDefinedSymbolSelect_type); + declarations.push_back(IfcDerivedMeasureValue_type); + declarations.push_back(IfcDocumentSelect_type); + declarations.push_back(IfcDraughtingCalloutElement_type); + declarations.push_back(IfcFillAreaStyleTileShapeSelect_type); + declarations.push_back(IfcFillStyleSelect_type); + declarations.push_back(IfcGeometricSetSelect_type); + declarations.push_back(IfcHatchLineDistanceSelect_type); + declarations.push_back(IfcLayeredItem_type); + declarations.push_back(IfcLibrarySelect_type); + declarations.push_back(IfcLightDistributionDataSourceSelect_type); + declarations.push_back(IfcMaterialSelect_type); + declarations.push_back(IfcMeasureValue_type); + declarations.push_back(IfcMetricValueSelect_type); + declarations.push_back(IfcObjectReferenceSelect_type); + declarations.push_back(IfcOrientationSelect_type); + declarations.push_back(IfcPointOrVertexPoint_type); + declarations.push_back(IfcPresentationStyleSelect_type); + declarations.push_back(IfcShell_type); + declarations.push_back(IfcSimpleValue_type); + declarations.push_back(IfcSizeSelect_type); + declarations.push_back(IfcSpecularHighlightSelect_type); + declarations.push_back(IfcStructuralActivityAssignmentSelect_type); + declarations.push_back(IfcSurfaceOrFaceSurface_type); + declarations.push_back(IfcSurfaceStyleElementSelect_type); + declarations.push_back(IfcSymbolStyleSelect_type); + declarations.push_back(IfcTextFontSelect_type); + declarations.push_back(IfcTextStyleSelect_type); + declarations.push_back(IfcTrimmingSelect_type); + declarations.push_back(IfcUnit_type); + declarations.push_back(IfcValue_type); + declarations.push_back(IfcVectorOrDirection_type); + declarations.push_back(IfcCurveFontOrScaledCurveFontSelect_type); + return new schema_definition("IFC2X3", declarations, true); +} + +const schema_definition& get_schema() { + + static const schema_definition* s = populate_schema(); + return *s; } #endif diff --git a/src/ifcparse/Ifc2x3.cpp b/src/ifcparse/Ifc2x3.cpp index 5406ae5c6b..bc9cdb79b4 100644 --- a/src/ifcparse/Ifc2x3.cpp +++ b/src/ifcparse/Ifc2x3.cpp @@ -27,6 +27,7 @@ #ifndef USE_IFC4 #include "../ifcparse/Ifc2x3.h" +#include "../ifcparse/IfcSchema.h" #include "../ifcparse/IfcException.h" #include "../ifcparse/IfcWrite.h" #include "../ifcparse/IfcWritableEntity.h" @@ -35,6 +36,778 @@ using namespace Ifc2x3; using namespace IfcParse; using namespace IfcWrite; +// External definitions +extern entity* Ifc2DCompositeCurve_type; +extern entity* IfcActionRequest_type; +extern entity* IfcActor_type; +extern entity* IfcActorRole_type; +extern entity* IfcActuatorType_type; +extern entity* IfcAddress_type; +extern entity* IfcAirTerminalBoxType_type; +extern entity* IfcAirTerminalType_type; +extern entity* IfcAirToAirHeatRecoveryType_type; +extern entity* IfcAlarmType_type; +extern entity* IfcAngularDimension_type; +extern entity* IfcAnnotation_type; +extern entity* IfcAnnotationCurveOccurrence_type; +extern entity* IfcAnnotationFillArea_type; +extern entity* IfcAnnotationFillAreaOccurrence_type; +extern entity* IfcAnnotationOccurrence_type; +extern entity* IfcAnnotationSurface_type; +extern entity* IfcAnnotationSurfaceOccurrence_type; +extern entity* IfcAnnotationSymbolOccurrence_type; +extern entity* IfcAnnotationTextOccurrence_type; +extern entity* IfcApplication_type; +extern entity* IfcAppliedValue_type; +extern entity* IfcAppliedValueRelationship_type; +extern entity* IfcApproval_type; +extern entity* IfcApprovalActorRelationship_type; +extern entity* IfcApprovalPropertyRelationship_type; +extern entity* IfcApprovalRelationship_type; +extern entity* IfcArbitraryClosedProfileDef_type; +extern entity* IfcArbitraryOpenProfileDef_type; +extern entity* IfcArbitraryProfileDefWithVoids_type; +extern entity* IfcAsset_type; +extern entity* IfcAsymmetricIShapeProfileDef_type; +extern entity* IfcAxis1Placement_type; +extern entity* IfcAxis2Placement2D_type; +extern entity* IfcAxis2Placement3D_type; +extern entity* IfcBSplineCurve_type; +extern entity* IfcBeam_type; +extern entity* IfcBeamType_type; +extern entity* IfcBezierCurve_type; +extern entity* IfcBlobTexture_type; +extern entity* IfcBlock_type; +extern entity* IfcBoilerType_type; +extern entity* IfcBooleanClippingResult_type; +extern entity* IfcBooleanResult_type; +extern entity* IfcBoundaryCondition_type; +extern entity* IfcBoundaryEdgeCondition_type; +extern entity* IfcBoundaryFaceCondition_type; +extern entity* IfcBoundaryNodeCondition_type; +extern entity* IfcBoundaryNodeConditionWarping_type; +extern entity* IfcBoundedCurve_type; +extern entity* IfcBoundedSurface_type; +extern entity* IfcBoundingBox_type; +extern entity* IfcBoxedHalfSpace_type; +extern entity* IfcBuilding_type; +extern entity* IfcBuildingElement_type; +extern entity* IfcBuildingElementComponent_type; +extern entity* IfcBuildingElementPart_type; +extern entity* IfcBuildingElementProxy_type; +extern entity* IfcBuildingElementProxyType_type; +extern entity* IfcBuildingElementType_type; +extern entity* IfcBuildingStorey_type; +extern entity* IfcCShapeProfileDef_type; +extern entity* IfcCableCarrierFittingType_type; +extern entity* IfcCableCarrierSegmentType_type; +extern entity* IfcCableSegmentType_type; +extern entity* IfcCalendarDate_type; +extern entity* IfcCartesianPoint_type; +extern entity* IfcCartesianTransformationOperator_type; +extern entity* IfcCartesianTransformationOperator2D_type; +extern entity* IfcCartesianTransformationOperator2DnonUniform_type; +extern entity* IfcCartesianTransformationOperator3D_type; +extern entity* IfcCartesianTransformationOperator3DnonUniform_type; +extern entity* IfcCenterLineProfileDef_type; +extern entity* IfcChamferEdgeFeature_type; +extern entity* IfcChillerType_type; +extern entity* IfcCircle_type; +extern entity* IfcCircleHollowProfileDef_type; +extern entity* IfcCircleProfileDef_type; +extern entity* IfcClassification_type; +extern entity* IfcClassificationItem_type; +extern entity* IfcClassificationItemRelationship_type; +extern entity* IfcClassificationNotation_type; +extern entity* IfcClassificationNotationFacet_type; +extern entity* IfcClassificationReference_type; +extern entity* IfcClosedShell_type; +extern entity* IfcCoilType_type; +extern entity* IfcColourRgb_type; +extern entity* IfcColourSpecification_type; +extern entity* IfcColumn_type; +extern entity* IfcColumnType_type; +extern entity* IfcComplexProperty_type; +extern entity* IfcCompositeCurve_type; +extern entity* IfcCompositeCurveSegment_type; +extern entity* IfcCompositeProfileDef_type; +extern entity* IfcCompressorType_type; +extern entity* IfcCondenserType_type; +extern entity* IfcCondition_type; +extern entity* IfcConditionCriterion_type; +extern entity* IfcConic_type; +extern entity* IfcConnectedFaceSet_type; +extern entity* IfcConnectionCurveGeometry_type; +extern entity* IfcConnectionGeometry_type; +extern entity* IfcConnectionPointEccentricity_type; +extern entity* IfcConnectionPointGeometry_type; +extern entity* IfcConnectionPortGeometry_type; +extern entity* IfcConnectionSurfaceGeometry_type; +extern entity* IfcConstraint_type; +extern entity* IfcConstraintAggregationRelationship_type; +extern entity* IfcConstraintClassificationRelationship_type; +extern entity* IfcConstraintRelationship_type; +extern entity* IfcConstructionEquipmentResource_type; +extern entity* IfcConstructionMaterialResource_type; +extern entity* IfcConstructionProductResource_type; +extern entity* IfcConstructionResource_type; +extern entity* IfcContextDependentUnit_type; +extern entity* IfcControl_type; +extern entity* IfcControllerType_type; +extern entity* IfcConversionBasedUnit_type; +extern entity* IfcCooledBeamType_type; +extern entity* IfcCoolingTowerType_type; +extern entity* IfcCoordinatedUniversalTimeOffset_type; +extern entity* IfcCostItem_type; +extern entity* IfcCostSchedule_type; +extern entity* IfcCostValue_type; +extern entity* IfcCovering_type; +extern entity* IfcCoveringType_type; +extern entity* IfcCraneRailAShapeProfileDef_type; +extern entity* IfcCraneRailFShapeProfileDef_type; +extern entity* IfcCrewResource_type; +extern entity* IfcCsgPrimitive3D_type; +extern entity* IfcCsgSolid_type; +extern entity* IfcCurrencyRelationship_type; +extern entity* IfcCurtainWall_type; +extern entity* IfcCurtainWallType_type; +extern entity* IfcCurve_type; +extern entity* IfcCurveBoundedPlane_type; +extern entity* IfcCurveStyle_type; +extern entity* IfcCurveStyleFont_type; +extern entity* IfcCurveStyleFontAndScaling_type; +extern entity* IfcCurveStyleFontPattern_type; +extern entity* IfcDamperType_type; +extern entity* IfcDateAndTime_type; +extern entity* IfcDefinedSymbol_type; +extern entity* IfcDerivedProfileDef_type; +extern entity* IfcDerivedUnit_type; +extern entity* IfcDerivedUnitElement_type; +extern entity* IfcDiameterDimension_type; +extern entity* IfcDimensionCalloutRelationship_type; +extern entity* IfcDimensionCurve_type; +extern entity* IfcDimensionCurveDirectedCallout_type; +extern entity* IfcDimensionCurveTerminator_type; +extern entity* IfcDimensionPair_type; +extern entity* IfcDimensionalExponents_type; +extern entity* IfcDirection_type; +extern entity* IfcDiscreteAccessory_type; +extern entity* IfcDiscreteAccessoryType_type; +extern entity* IfcDistributionChamberElement_type; +extern entity* IfcDistributionChamberElementType_type; +extern entity* IfcDistributionControlElement_type; +extern entity* IfcDistributionControlElementType_type; +extern entity* IfcDistributionElement_type; +extern entity* IfcDistributionElementType_type; +extern entity* IfcDistributionFlowElement_type; +extern entity* IfcDistributionFlowElementType_type; +extern entity* IfcDistributionPort_type; +extern entity* IfcDocumentElectronicFormat_type; +extern entity* IfcDocumentInformation_type; +extern entity* IfcDocumentInformationRelationship_type; +extern entity* IfcDocumentReference_type; +extern entity* IfcDoor_type; +extern entity* IfcDoorLiningProperties_type; +extern entity* IfcDoorPanelProperties_type; +extern entity* IfcDoorStyle_type; +extern entity* IfcDraughtingCallout_type; +extern entity* IfcDraughtingCalloutRelationship_type; +extern entity* IfcDraughtingPreDefinedColour_type; +extern entity* IfcDraughtingPreDefinedCurveFont_type; +extern entity* IfcDraughtingPreDefinedTextFont_type; +extern entity* IfcDuctFittingType_type; +extern entity* IfcDuctSegmentType_type; +extern entity* IfcDuctSilencerType_type; +extern entity* IfcEdge_type; +extern entity* IfcEdgeCurve_type; +extern entity* IfcEdgeFeature_type; +extern entity* IfcEdgeLoop_type; +extern entity* IfcElectricApplianceType_type; +extern entity* IfcElectricDistributionPoint_type; +extern entity* IfcElectricFlowStorageDeviceType_type; +extern entity* IfcElectricGeneratorType_type; +extern entity* IfcElectricHeaterType_type; +extern entity* IfcElectricMotorType_type; +extern entity* IfcElectricTimeControlType_type; +extern entity* IfcElectricalBaseProperties_type; +extern entity* IfcElectricalCircuit_type; +extern entity* IfcElectricalElement_type; +extern entity* IfcElement_type; +extern entity* IfcElementAssembly_type; +extern entity* IfcElementComponent_type; +extern entity* IfcElementComponentType_type; +extern entity* IfcElementQuantity_type; +extern entity* IfcElementType_type; +extern entity* IfcElementarySurface_type; +extern entity* IfcEllipse_type; +extern entity* IfcEllipseProfileDef_type; +extern entity* IfcEnergyConversionDevice_type; +extern entity* IfcEnergyConversionDeviceType_type; +extern entity* IfcEnergyProperties_type; +extern entity* IfcEnvironmentalImpactValue_type; +extern entity* IfcEquipmentElement_type; +extern entity* IfcEquipmentStandard_type; +extern entity* IfcEvaporativeCoolerType_type; +extern entity* IfcEvaporatorType_type; +extern entity* IfcExtendedMaterialProperties_type; +extern entity* IfcExternalReference_type; +extern entity* IfcExternallyDefinedHatchStyle_type; +extern entity* IfcExternallyDefinedSurfaceStyle_type; +extern entity* IfcExternallyDefinedSymbol_type; +extern entity* IfcExternallyDefinedTextFont_type; +extern entity* IfcExtrudedAreaSolid_type; +extern entity* IfcFace_type; +extern entity* IfcFaceBasedSurfaceModel_type; +extern entity* IfcFaceBound_type; +extern entity* IfcFaceOuterBound_type; +extern entity* IfcFaceSurface_type; +extern entity* IfcFacetedBrep_type; +extern entity* IfcFacetedBrepWithVoids_type; +extern entity* IfcFailureConnectionCondition_type; +extern entity* IfcFanType_type; +extern entity* IfcFastener_type; +extern entity* IfcFastenerType_type; +extern entity* IfcFeatureElement_type; +extern entity* IfcFeatureElementAddition_type; +extern entity* IfcFeatureElementSubtraction_type; +extern entity* IfcFillAreaStyle_type; +extern entity* IfcFillAreaStyleHatching_type; +extern entity* IfcFillAreaStyleTileSymbolWithStyle_type; +extern entity* IfcFillAreaStyleTiles_type; +extern entity* IfcFilterType_type; +extern entity* IfcFireSuppressionTerminalType_type; +extern entity* IfcFlowController_type; +extern entity* IfcFlowControllerType_type; +extern entity* IfcFlowFitting_type; +extern entity* IfcFlowFittingType_type; +extern entity* IfcFlowInstrumentType_type; +extern entity* IfcFlowMeterType_type; +extern entity* IfcFlowMovingDevice_type; +extern entity* IfcFlowMovingDeviceType_type; +extern entity* IfcFlowSegment_type; +extern entity* IfcFlowSegmentType_type; +extern entity* IfcFlowStorageDevice_type; +extern entity* IfcFlowStorageDeviceType_type; +extern entity* IfcFlowTerminal_type; +extern entity* IfcFlowTerminalType_type; +extern entity* IfcFlowTreatmentDevice_type; +extern entity* IfcFlowTreatmentDeviceType_type; +extern entity* IfcFluidFlowProperties_type; +extern entity* IfcFooting_type; +extern entity* IfcFuelProperties_type; +extern entity* IfcFurnishingElement_type; +extern entity* IfcFurnishingElementType_type; +extern entity* IfcFurnitureStandard_type; +extern entity* IfcFurnitureType_type; +extern entity* IfcGasTerminalType_type; +extern entity* IfcGeneralMaterialProperties_type; +extern entity* IfcGeneralProfileProperties_type; +extern entity* IfcGeometricCurveSet_type; +extern entity* IfcGeometricRepresentationContext_type; +extern entity* IfcGeometricRepresentationItem_type; +extern entity* IfcGeometricRepresentationSubContext_type; +extern entity* IfcGeometricSet_type; +extern entity* IfcGrid_type; +extern entity* IfcGridAxis_type; +extern entity* IfcGridPlacement_type; +extern entity* IfcGroup_type; +extern entity* IfcHalfSpaceSolid_type; +extern entity* IfcHeatExchangerType_type; +extern entity* IfcHumidifierType_type; +extern entity* IfcHygroscopicMaterialProperties_type; +extern entity* IfcIShapeProfileDef_type; +extern entity* IfcImageTexture_type; +extern entity* IfcInventory_type; +extern entity* IfcIrregularTimeSeries_type; +extern entity* IfcIrregularTimeSeriesValue_type; +extern entity* IfcJunctionBoxType_type; +extern entity* IfcLShapeProfileDef_type; +extern entity* IfcLaborResource_type; +extern entity* IfcLampType_type; +extern entity* IfcLibraryInformation_type; +extern entity* IfcLibraryReference_type; +extern entity* IfcLightDistributionData_type; +extern entity* IfcLightFixtureType_type; +extern entity* IfcLightIntensityDistribution_type; +extern entity* IfcLightSource_type; +extern entity* IfcLightSourceAmbient_type; +extern entity* IfcLightSourceDirectional_type; +extern entity* IfcLightSourceGoniometric_type; +extern entity* IfcLightSourcePositional_type; +extern entity* IfcLightSourceSpot_type; +extern entity* IfcLine_type; +extern entity* IfcLinearDimension_type; +extern entity* IfcLocalPlacement_type; +extern entity* IfcLocalTime_type; +extern entity* IfcLoop_type; +extern entity* IfcManifoldSolidBrep_type; +extern entity* IfcMappedItem_type; +extern entity* IfcMaterial_type; +extern entity* IfcMaterialClassificationRelationship_type; +extern entity* IfcMaterialDefinitionRepresentation_type; +extern entity* IfcMaterialLayer_type; +extern entity* IfcMaterialLayerSet_type; +extern entity* IfcMaterialLayerSetUsage_type; +extern entity* IfcMaterialList_type; +extern entity* IfcMaterialProperties_type; +extern entity* IfcMeasureWithUnit_type; +extern entity* IfcMechanicalConcreteMaterialProperties_type; +extern entity* IfcMechanicalFastener_type; +extern entity* IfcMechanicalFastenerType_type; +extern entity* IfcMechanicalMaterialProperties_type; +extern entity* IfcMechanicalSteelMaterialProperties_type; +extern entity* IfcMember_type; +extern entity* IfcMemberType_type; +extern entity* IfcMetric_type; +extern entity* IfcMonetaryUnit_type; +extern entity* IfcMotorConnectionType_type; +extern entity* IfcMove_type; +extern entity* IfcNamedUnit_type; +extern entity* IfcObject_type; +extern entity* IfcObjectDefinition_type; +extern entity* IfcObjectPlacement_type; +extern entity* IfcObjective_type; +extern entity* IfcOccupant_type; +extern entity* IfcOffsetCurve2D_type; +extern entity* IfcOffsetCurve3D_type; +extern entity* IfcOneDirectionRepeatFactor_type; +extern entity* IfcOpenShell_type; +extern entity* IfcOpeningElement_type; +extern entity* IfcOpticalMaterialProperties_type; +extern entity* IfcOrderAction_type; +extern entity* IfcOrganization_type; +extern entity* IfcOrganizationRelationship_type; +extern entity* IfcOrientedEdge_type; +extern entity* IfcOutletType_type; +extern entity* IfcOwnerHistory_type; +extern entity* IfcParameterizedProfileDef_type; +extern entity* IfcPath_type; +extern entity* IfcPerformanceHistory_type; +extern entity* IfcPermeableCoveringProperties_type; +extern entity* IfcPermit_type; +extern entity* IfcPerson_type; +extern entity* IfcPersonAndOrganization_type; +extern entity* IfcPhysicalComplexQuantity_type; +extern entity* IfcPhysicalQuantity_type; +extern entity* IfcPhysicalSimpleQuantity_type; +extern entity* IfcPile_type; +extern entity* IfcPipeFittingType_type; +extern entity* IfcPipeSegmentType_type; +extern entity* IfcPixelTexture_type; +extern entity* IfcPlacement_type; +extern entity* IfcPlanarBox_type; +extern entity* IfcPlanarExtent_type; +extern entity* IfcPlane_type; +extern entity* IfcPlate_type; +extern entity* IfcPlateType_type; +extern entity* IfcPoint_type; +extern entity* IfcPointOnCurve_type; +extern entity* IfcPointOnSurface_type; +extern entity* IfcPolyLoop_type; +extern entity* IfcPolygonalBoundedHalfSpace_type; +extern entity* IfcPolyline_type; +extern entity* IfcPort_type; +extern entity* IfcPostalAddress_type; +extern entity* IfcPreDefinedColour_type; +extern entity* IfcPreDefinedCurveFont_type; +extern entity* IfcPreDefinedDimensionSymbol_type; +extern entity* IfcPreDefinedItem_type; +extern entity* IfcPreDefinedPointMarkerSymbol_type; +extern entity* IfcPreDefinedSymbol_type; +extern entity* IfcPreDefinedTerminatorSymbol_type; +extern entity* IfcPreDefinedTextFont_type; +extern entity* IfcPresentationLayerAssignment_type; +extern entity* IfcPresentationLayerWithStyle_type; +extern entity* IfcPresentationStyle_type; +extern entity* IfcPresentationStyleAssignment_type; +extern entity* IfcProcedure_type; +extern entity* IfcProcess_type; +extern entity* IfcProduct_type; +extern entity* IfcProductDefinitionShape_type; +extern entity* IfcProductRepresentation_type; +extern entity* IfcProductsOfCombustionProperties_type; +extern entity* IfcProfileDef_type; +extern entity* IfcProfileProperties_type; +extern entity* IfcProject_type; +extern entity* IfcProjectOrder_type; +extern entity* IfcProjectOrderRecord_type; +extern entity* IfcProjectionCurve_type; +extern entity* IfcProjectionElement_type; +extern entity* IfcProperty_type; +extern entity* IfcPropertyBoundedValue_type; +extern entity* IfcPropertyConstraintRelationship_type; +extern entity* IfcPropertyDefinition_type; +extern entity* IfcPropertyDependencyRelationship_type; +extern entity* IfcPropertyEnumeratedValue_type; +extern entity* IfcPropertyEnumeration_type; +extern entity* IfcPropertyListValue_type; +extern entity* IfcPropertyReferenceValue_type; +extern entity* IfcPropertySet_type; +extern entity* IfcPropertySetDefinition_type; +extern entity* IfcPropertySingleValue_type; +extern entity* IfcPropertyTableValue_type; +extern entity* IfcProtectiveDeviceType_type; +extern entity* IfcProxy_type; +extern entity* IfcPumpType_type; +extern entity* IfcQuantityArea_type; +extern entity* IfcQuantityCount_type; +extern entity* IfcQuantityLength_type; +extern entity* IfcQuantityTime_type; +extern entity* IfcQuantityVolume_type; +extern entity* IfcQuantityWeight_type; +extern entity* IfcRadiusDimension_type; +extern entity* IfcRailing_type; +extern entity* IfcRailingType_type; +extern entity* IfcRamp_type; +extern entity* IfcRampFlight_type; +extern entity* IfcRampFlightType_type; +extern entity* IfcRationalBezierCurve_type; +extern entity* IfcRectangleHollowProfileDef_type; +extern entity* IfcRectangleProfileDef_type; +extern entity* IfcRectangularPyramid_type; +extern entity* IfcRectangularTrimmedSurface_type; +extern entity* IfcReferencesValueDocument_type; +extern entity* IfcRegularTimeSeries_type; +extern entity* IfcReinforcementBarProperties_type; +extern entity* IfcReinforcementDefinitionProperties_type; +extern entity* IfcReinforcingBar_type; +extern entity* IfcReinforcingElement_type; +extern entity* IfcReinforcingMesh_type; +extern entity* IfcRelAggregates_type; +extern entity* IfcRelAssigns_type; +extern entity* IfcRelAssignsTasks_type; +extern entity* IfcRelAssignsToActor_type; +extern entity* IfcRelAssignsToControl_type; +extern entity* IfcRelAssignsToGroup_type; +extern entity* IfcRelAssignsToProcess_type; +extern entity* IfcRelAssignsToProduct_type; +extern entity* IfcRelAssignsToProjectOrder_type; +extern entity* IfcRelAssignsToResource_type; +extern entity* IfcRelAssociates_type; +extern entity* IfcRelAssociatesAppliedValue_type; +extern entity* IfcRelAssociatesApproval_type; +extern entity* IfcRelAssociatesClassification_type; +extern entity* IfcRelAssociatesConstraint_type; +extern entity* IfcRelAssociatesDocument_type; +extern entity* IfcRelAssociatesLibrary_type; +extern entity* IfcRelAssociatesMaterial_type; +extern entity* IfcRelAssociatesProfileProperties_type; +extern entity* IfcRelConnects_type; +extern entity* IfcRelConnectsElements_type; +extern entity* IfcRelConnectsPathElements_type; +extern entity* IfcRelConnectsPortToElement_type; +extern entity* IfcRelConnectsPorts_type; +extern entity* IfcRelConnectsStructuralActivity_type; +extern entity* IfcRelConnectsStructuralElement_type; +extern entity* IfcRelConnectsStructuralMember_type; +extern entity* IfcRelConnectsWithEccentricity_type; +extern entity* IfcRelConnectsWithRealizingElements_type; +extern entity* IfcRelContainedInSpatialStructure_type; +extern entity* IfcRelCoversBldgElements_type; +extern entity* IfcRelCoversSpaces_type; +extern entity* IfcRelDecomposes_type; +extern entity* IfcRelDefines_type; +extern entity* IfcRelDefinesByProperties_type; +extern entity* IfcRelDefinesByType_type; +extern entity* IfcRelFillsElement_type; +extern entity* IfcRelFlowControlElements_type; +extern entity* IfcRelInteractionRequirements_type; +extern entity* IfcRelNests_type; +extern entity* IfcRelOccupiesSpaces_type; +extern entity* IfcRelOverridesProperties_type; +extern entity* IfcRelProjectsElement_type; +extern entity* IfcRelReferencedInSpatialStructure_type; +extern entity* IfcRelSchedulesCostItems_type; +extern entity* IfcRelSequence_type; +extern entity* IfcRelServicesBuildings_type; +extern entity* IfcRelSpaceBoundary_type; +extern entity* IfcRelVoidsElement_type; +extern entity* IfcRelationship_type; +extern entity* IfcRelaxation_type; +extern entity* IfcRepresentation_type; +extern entity* IfcRepresentationContext_type; +extern entity* IfcRepresentationItem_type; +extern entity* IfcRepresentationMap_type; +extern entity* IfcResource_type; +extern entity* IfcRevolvedAreaSolid_type; +extern entity* IfcRibPlateProfileProperties_type; +extern entity* IfcRightCircularCone_type; +extern entity* IfcRightCircularCylinder_type; +extern entity* IfcRoof_type; +extern entity* IfcRoot_type; +extern entity* IfcRoundedEdgeFeature_type; +extern entity* IfcRoundedRectangleProfileDef_type; +extern entity* IfcSIUnit_type; +extern entity* IfcSanitaryTerminalType_type; +extern entity* IfcScheduleTimeControl_type; +extern entity* IfcSectionProperties_type; +extern entity* IfcSectionReinforcementProperties_type; +extern entity* IfcSectionedSpine_type; +extern entity* IfcSensorType_type; +extern entity* IfcServiceLife_type; +extern entity* IfcServiceLifeFactor_type; +extern entity* IfcShapeAspect_type; +extern entity* IfcShapeModel_type; +extern entity* IfcShapeRepresentation_type; +extern entity* IfcShellBasedSurfaceModel_type; +extern entity* IfcSimpleProperty_type; +extern entity* IfcSite_type; +extern entity* IfcSlab_type; +extern entity* IfcSlabType_type; +extern entity* IfcSlippageConnectionCondition_type; +extern entity* IfcSolidModel_type; +extern entity* IfcSoundProperties_type; +extern entity* IfcSoundValue_type; +extern entity* IfcSpace_type; +extern entity* IfcSpaceHeaterType_type; +extern entity* IfcSpaceProgram_type; +extern entity* IfcSpaceThermalLoadProperties_type; +extern entity* IfcSpaceType_type; +extern entity* IfcSpatialStructureElement_type; +extern entity* IfcSpatialStructureElementType_type; +extern entity* IfcSphere_type; +extern entity* IfcStackTerminalType_type; +extern entity* IfcStair_type; +extern entity* IfcStairFlight_type; +extern entity* IfcStairFlightType_type; +extern entity* IfcStructuralAction_type; +extern entity* IfcStructuralActivity_type; +extern entity* IfcStructuralAnalysisModel_type; +extern entity* IfcStructuralConnection_type; +extern entity* IfcStructuralConnectionCondition_type; +extern entity* IfcStructuralCurveConnection_type; +extern entity* IfcStructuralCurveMember_type; +extern entity* IfcStructuralCurveMemberVarying_type; +extern entity* IfcStructuralItem_type; +extern entity* IfcStructuralLinearAction_type; +extern entity* IfcStructuralLinearActionVarying_type; +extern entity* IfcStructuralLoad_type; +extern entity* IfcStructuralLoadGroup_type; +extern entity* IfcStructuralLoadLinearForce_type; +extern entity* IfcStructuralLoadPlanarForce_type; +extern entity* IfcStructuralLoadSingleDisplacement_type; +extern entity* IfcStructuralLoadSingleDisplacementDistortion_type; +extern entity* IfcStructuralLoadSingleForce_type; +extern entity* IfcStructuralLoadSingleForceWarping_type; +extern entity* IfcStructuralLoadStatic_type; +extern entity* IfcStructuralLoadTemperature_type; +extern entity* IfcStructuralMember_type; +extern entity* IfcStructuralPlanarAction_type; +extern entity* IfcStructuralPlanarActionVarying_type; +extern entity* IfcStructuralPointAction_type; +extern entity* IfcStructuralPointConnection_type; +extern entity* IfcStructuralPointReaction_type; +extern entity* IfcStructuralProfileProperties_type; +extern entity* IfcStructuralReaction_type; +extern entity* IfcStructuralResultGroup_type; +extern entity* IfcStructuralSteelProfileProperties_type; +extern entity* IfcStructuralSurfaceConnection_type; +extern entity* IfcStructuralSurfaceMember_type; +extern entity* IfcStructuralSurfaceMemberVarying_type; +extern entity* IfcStructuredDimensionCallout_type; +extern entity* IfcStyleModel_type; +extern entity* IfcStyledItem_type; +extern entity* IfcStyledRepresentation_type; +extern entity* IfcSubContractResource_type; +extern entity* IfcSubedge_type; +extern entity* IfcSurface_type; +extern entity* IfcSurfaceCurveSweptAreaSolid_type; +extern entity* IfcSurfaceOfLinearExtrusion_type; +extern entity* IfcSurfaceOfRevolution_type; +extern entity* IfcSurfaceStyle_type; +extern entity* IfcSurfaceStyleLighting_type; +extern entity* IfcSurfaceStyleRefraction_type; +extern entity* IfcSurfaceStyleRendering_type; +extern entity* IfcSurfaceStyleShading_type; +extern entity* IfcSurfaceStyleWithTextures_type; +extern entity* IfcSurfaceTexture_type; +extern entity* IfcSweptAreaSolid_type; +extern entity* IfcSweptDiskSolid_type; +extern entity* IfcSweptSurface_type; +extern entity* IfcSwitchingDeviceType_type; +extern entity* IfcSymbolStyle_type; +extern entity* IfcSystem_type; +extern entity* IfcSystemFurnitureElementType_type; +extern entity* IfcTShapeProfileDef_type; +extern entity* IfcTable_type; +extern entity* IfcTableRow_type; +extern entity* IfcTankType_type; +extern entity* IfcTask_type; +extern entity* IfcTelecomAddress_type; +extern entity* IfcTendon_type; +extern entity* IfcTendonAnchor_type; +extern entity* IfcTerminatorSymbol_type; +extern entity* IfcTextLiteral_type; +extern entity* IfcTextLiteralWithExtent_type; +extern entity* IfcTextStyle_type; +extern entity* IfcTextStyleFontModel_type; +extern entity* IfcTextStyleForDefinedFont_type; +extern entity* IfcTextStyleTextModel_type; +extern entity* IfcTextStyleWithBoxCharacteristics_type; +extern entity* IfcTextureCoordinate_type; +extern entity* IfcTextureCoordinateGenerator_type; +extern entity* IfcTextureMap_type; +extern entity* IfcTextureVertex_type; +extern entity* IfcThermalMaterialProperties_type; +extern entity* IfcTimeSeries_type; +extern entity* IfcTimeSeriesReferenceRelationship_type; +extern entity* IfcTimeSeriesSchedule_type; +extern entity* IfcTimeSeriesValue_type; +extern entity* IfcTopologicalRepresentationItem_type; +extern entity* IfcTopologyRepresentation_type; +extern entity* IfcTransformerType_type; +extern entity* IfcTransportElement_type; +extern entity* IfcTransportElementType_type; +extern entity* IfcTrapeziumProfileDef_type; +extern entity* IfcTrimmedCurve_type; +extern entity* IfcTubeBundleType_type; +extern entity* IfcTwoDirectionRepeatFactor_type; +extern entity* IfcTypeObject_type; +extern entity* IfcTypeProduct_type; +extern entity* IfcUShapeProfileDef_type; +extern entity* IfcUnitAssignment_type; +extern entity* IfcUnitaryEquipmentType_type; +extern entity* IfcValveType_type; +extern entity* IfcVector_type; +extern entity* IfcVertex_type; +extern entity* IfcVertexBasedTextureMap_type; +extern entity* IfcVertexLoop_type; +extern entity* IfcVertexPoint_type; +extern entity* IfcVibrationIsolatorType_type; +extern entity* IfcVirtualElement_type; +extern entity* IfcVirtualGridIntersection_type; +extern entity* IfcWall_type; +extern entity* IfcWallStandardCase_type; +extern entity* IfcWallType_type; +extern entity* IfcWasteTerminalType_type; +extern entity* IfcWaterProperties_type; +extern entity* IfcWindow_type; +extern entity* IfcWindowLiningProperties_type; +extern entity* IfcWindowPanelProperties_type; +extern entity* IfcWindowStyle_type; +extern entity* IfcWorkControl_type; +extern entity* IfcWorkPlan_type; +extern entity* IfcWorkSchedule_type; +extern entity* IfcZShapeProfileDef_type; +extern entity* IfcZone_type; +extern type_declaration* IfcAbsorbedDoseMeasure_type; +extern type_declaration* IfcAccelerationMeasure_type; +extern type_declaration* IfcAmountOfSubstanceMeasure_type; +extern type_declaration* IfcAngularVelocityMeasure_type; +extern type_declaration* IfcAreaMeasure_type; +extern type_declaration* IfcBoolean_type; +extern type_declaration* IfcBoxAlignment_type; +extern type_declaration* IfcComplexNumber_type; +extern type_declaration* IfcCompoundPlaneAngleMeasure_type; +extern type_declaration* IfcContextDependentMeasure_type; +extern type_declaration* IfcCountMeasure_type; +extern type_declaration* IfcCurvatureMeasure_type; +extern type_declaration* IfcDayInMonthNumber_type; +extern type_declaration* IfcDaylightSavingHour_type; +extern type_declaration* IfcDescriptiveMeasure_type; +extern type_declaration* IfcDimensionCount_type; +extern type_declaration* IfcDoseEquivalentMeasure_type; +extern type_declaration* IfcDynamicViscosityMeasure_type; +extern type_declaration* IfcElectricCapacitanceMeasure_type; +extern type_declaration* IfcElectricChargeMeasure_type; +extern type_declaration* IfcElectricConductanceMeasure_type; +extern type_declaration* IfcElectricCurrentMeasure_type; +extern type_declaration* IfcElectricResistanceMeasure_type; +extern type_declaration* IfcElectricVoltageMeasure_type; +extern type_declaration* IfcEnergyMeasure_type; +extern type_declaration* IfcFontStyle_type; +extern type_declaration* IfcFontVariant_type; +extern type_declaration* IfcFontWeight_type; +extern type_declaration* IfcForceMeasure_type; +extern type_declaration* IfcFrequencyMeasure_type; +extern type_declaration* IfcGloballyUniqueId_type; +extern type_declaration* IfcHeatFluxDensityMeasure_type; +extern type_declaration* IfcHeatingValueMeasure_type; +extern type_declaration* IfcHourInDay_type; +extern type_declaration* IfcIdentifier_type; +extern type_declaration* IfcIlluminanceMeasure_type; +extern type_declaration* IfcInductanceMeasure_type; +extern type_declaration* IfcInteger_type; +extern type_declaration* IfcIntegerCountRateMeasure_type; +extern type_declaration* IfcIonConcentrationMeasure_type; +extern type_declaration* IfcIsothermalMoistureCapacityMeasure_type; +extern type_declaration* IfcKinematicViscosityMeasure_type; +extern type_declaration* IfcLabel_type; +extern type_declaration* IfcLengthMeasure_type; +extern type_declaration* IfcLinearForceMeasure_type; +extern type_declaration* IfcLinearMomentMeasure_type; +extern type_declaration* IfcLinearStiffnessMeasure_type; +extern type_declaration* IfcLinearVelocityMeasure_type; +extern type_declaration* IfcLogical_type; +extern type_declaration* IfcLuminousFluxMeasure_type; +extern type_declaration* IfcLuminousIntensityDistributionMeasure_type; +extern type_declaration* IfcLuminousIntensityMeasure_type; +extern type_declaration* IfcMagneticFluxDensityMeasure_type; +extern type_declaration* IfcMagneticFluxMeasure_type; +extern type_declaration* IfcMassDensityMeasure_type; +extern type_declaration* IfcMassFlowRateMeasure_type; +extern type_declaration* IfcMassMeasure_type; +extern type_declaration* IfcMassPerLengthMeasure_type; +extern type_declaration* IfcMinuteInHour_type; +extern type_declaration* IfcModulusOfElasticityMeasure_type; +extern type_declaration* IfcModulusOfLinearSubgradeReactionMeasure_type; +extern type_declaration* IfcModulusOfRotationalSubgradeReactionMeasure_type; +extern type_declaration* IfcModulusOfSubgradeReactionMeasure_type; +extern type_declaration* IfcMoistureDiffusivityMeasure_type; +extern type_declaration* IfcMolecularWeightMeasure_type; +extern type_declaration* IfcMomentOfInertiaMeasure_type; +extern type_declaration* IfcMonetaryMeasure_type; +extern type_declaration* IfcMonthInYearNumber_type; +extern type_declaration* IfcNormalisedRatioMeasure_type; +extern type_declaration* IfcNumericMeasure_type; +extern type_declaration* IfcPHMeasure_type; +extern type_declaration* IfcParameterValue_type; +extern type_declaration* IfcPlanarForceMeasure_type; +extern type_declaration* IfcPlaneAngleMeasure_type; +extern type_declaration* IfcPositiveLengthMeasure_type; +extern type_declaration* IfcPositivePlaneAngleMeasure_type; +extern type_declaration* IfcPositiveRatioMeasure_type; +extern type_declaration* IfcPowerMeasure_type; +extern type_declaration* IfcPresentableText_type; +extern type_declaration* IfcPressureMeasure_type; +extern type_declaration* IfcRadioActivityMeasure_type; +extern type_declaration* IfcRatioMeasure_type; +extern type_declaration* IfcReal_type; +extern type_declaration* IfcRotationalFrequencyMeasure_type; +extern type_declaration* IfcRotationalMassMeasure_type; +extern type_declaration* IfcRotationalStiffnessMeasure_type; +extern type_declaration* IfcSecondInMinute_type; +extern type_declaration* IfcSectionModulusMeasure_type; +extern type_declaration* IfcSectionalAreaIntegralMeasure_type; +extern type_declaration* IfcShearModulusMeasure_type; +extern type_declaration* IfcSolidAngleMeasure_type; +extern type_declaration* IfcSoundPowerMeasure_type; +extern type_declaration* IfcSoundPressureMeasure_type; +extern type_declaration* IfcSpecificHeatCapacityMeasure_type; +extern type_declaration* IfcSpecularExponent_type; +extern type_declaration* IfcSpecularRoughness_type; +extern type_declaration* IfcTemperatureGradientMeasure_type; +extern type_declaration* IfcText_type; +extern type_declaration* IfcTextAlignment_type; +extern type_declaration* IfcTextDecoration_type; +extern type_declaration* IfcTextFontName_type; +extern type_declaration* IfcTextTransformation_type; +extern type_declaration* IfcThermalAdmittanceMeasure_type; +extern type_declaration* IfcThermalConductivityMeasure_type; +extern type_declaration* IfcThermalExpansionCoefficientMeasure_type; +extern type_declaration* IfcThermalResistanceMeasure_type; +extern type_declaration* IfcThermalTransmittanceMeasure_type; +extern type_declaration* IfcThermodynamicTemperatureMeasure_type; +extern type_declaration* IfcTimeMeasure_type; +extern type_declaration* IfcTimeStamp_type; +extern type_declaration* IfcTorqueMeasure_type; +extern type_declaration* IfcVaporPermeabilityMeasure_type; +extern type_declaration* IfcVolumeMeasure_type; +extern type_declaration* IfcVolumetricFlowRateMeasure_type; +extern type_declaration* IfcWarpingConstantMeasure_type; +extern type_declaration* IfcWarpingMomentMeasure_type; +extern type_declaration* IfcYearNumber_type; + IfcUtil::IfcBaseClass* Ifc2x3::SchemaEntity(IfcAbstractEntity* e) { switch(e->type()) { case Type::IfcAbsorbedDoseMeasure: return new IfcAbsorbedDoseMeasure(e); break; @@ -5322,9099 +6095,9401 @@ IfcWorkControlTypeEnum::IfcWorkControlTypeEnum IfcWorkControlTypeEnum::FromStrin // Function implementations for IfcAbsorbedDoseMeasure -IfcUtil::ArgumentType IfcAbsorbedDoseMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcAbsorbedDoseMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcAbsorbedDoseMeasure::is(Type::Enum v) const { return v == IfcAbsorbedDoseMeasure::Class(); } -Type::Enum IfcAbsorbedDoseMeasure::type() const { return Type::IfcAbsorbedDoseMeasure; } Type::Enum IfcAbsorbedDoseMeasure::Class() { return Type::IfcAbsorbedDoseMeasure; } -IfcAbsorbedDoseMeasure::IfcAbsorbedDoseMeasure(IfcAbstractEntity* e) { entity = e; } -IfcAbsorbedDoseMeasure::IfcAbsorbedDoseMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAbsorbedDoseMeasure); e->setArgument(0, v); entity = e; } -IfcAbsorbedDoseMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcAbsorbedDoseMeasure::declaration() const { return *IfcAbsorbedDoseMeasure_type; } +IfcAbsorbedDoseMeasure::IfcAbsorbedDoseMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcAbsorbedDoseMeasure::IfcAbsorbedDoseMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAbsorbedDoseMeasure); e->setArgument(0, v); data_ = e; } +IfcAbsorbedDoseMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcAccelerationMeasure -IfcUtil::ArgumentType IfcAccelerationMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcAccelerationMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcAccelerationMeasure::is(Type::Enum v) const { return v == IfcAccelerationMeasure::Class(); } -Type::Enum IfcAccelerationMeasure::type() const { return Type::IfcAccelerationMeasure; } Type::Enum IfcAccelerationMeasure::Class() { return Type::IfcAccelerationMeasure; } -IfcAccelerationMeasure::IfcAccelerationMeasure(IfcAbstractEntity* e) { entity = e; } -IfcAccelerationMeasure::IfcAccelerationMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAccelerationMeasure); e->setArgument(0, v); entity = e; } -IfcAccelerationMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcAccelerationMeasure::declaration() const { return *IfcAccelerationMeasure_type; } +IfcAccelerationMeasure::IfcAccelerationMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcAccelerationMeasure::IfcAccelerationMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAccelerationMeasure); e->setArgument(0, v); data_ = e; } +IfcAccelerationMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcAmountOfSubstanceMeasure -IfcUtil::ArgumentType IfcAmountOfSubstanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcAmountOfSubstanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcAmountOfSubstanceMeasure::is(Type::Enum v) const { return v == IfcAmountOfSubstanceMeasure::Class(); } -Type::Enum IfcAmountOfSubstanceMeasure::type() const { return Type::IfcAmountOfSubstanceMeasure; } Type::Enum IfcAmountOfSubstanceMeasure::Class() { return Type::IfcAmountOfSubstanceMeasure; } -IfcAmountOfSubstanceMeasure::IfcAmountOfSubstanceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcAmountOfSubstanceMeasure::IfcAmountOfSubstanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAmountOfSubstanceMeasure); e->setArgument(0, v); entity = e; } -IfcAmountOfSubstanceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcAmountOfSubstanceMeasure::declaration() const { return *IfcAmountOfSubstanceMeasure_type; } +IfcAmountOfSubstanceMeasure::IfcAmountOfSubstanceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcAmountOfSubstanceMeasure::IfcAmountOfSubstanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAmountOfSubstanceMeasure); e->setArgument(0, v); data_ = e; } +IfcAmountOfSubstanceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcAngularVelocityMeasure -IfcUtil::ArgumentType IfcAngularVelocityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcAngularVelocityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcAngularVelocityMeasure::is(Type::Enum v) const { return v == IfcAngularVelocityMeasure::Class(); } -Type::Enum IfcAngularVelocityMeasure::type() const { return Type::IfcAngularVelocityMeasure; } Type::Enum IfcAngularVelocityMeasure::Class() { return Type::IfcAngularVelocityMeasure; } -IfcAngularVelocityMeasure::IfcAngularVelocityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcAngularVelocityMeasure::IfcAngularVelocityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAngularVelocityMeasure); e->setArgument(0, v); entity = e; } -IfcAngularVelocityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcAngularVelocityMeasure::declaration() const { return *IfcAngularVelocityMeasure_type; } +IfcAngularVelocityMeasure::IfcAngularVelocityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcAngularVelocityMeasure::IfcAngularVelocityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAngularVelocityMeasure); e->setArgument(0, v); data_ = e; } +IfcAngularVelocityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcAreaMeasure -IfcUtil::ArgumentType IfcAreaMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcAreaMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcAreaMeasure::is(Type::Enum v) const { return v == IfcAreaMeasure::Class(); } -Type::Enum IfcAreaMeasure::type() const { return Type::IfcAreaMeasure; } Type::Enum IfcAreaMeasure::Class() { return Type::IfcAreaMeasure; } -IfcAreaMeasure::IfcAreaMeasure(IfcAbstractEntity* e) { entity = e; } -IfcAreaMeasure::IfcAreaMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAreaMeasure); e->setArgument(0, v); entity = e; } -IfcAreaMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcAreaMeasure::declaration() const { return *IfcAreaMeasure_type; } +IfcAreaMeasure::IfcAreaMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcAreaMeasure::IfcAreaMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAreaMeasure); e->setArgument(0, v); data_ = e; } +IfcAreaMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcBoolean -IfcUtil::ArgumentType IfcBoolean::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_BOOL; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcBoolean::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcBoolean::is(Type::Enum v) const { return v == IfcBoolean::Class(); } -Type::Enum IfcBoolean::type() const { return Type::IfcBoolean; } Type::Enum IfcBoolean::Class() { return Type::IfcBoolean; } -IfcBoolean::IfcBoolean(IfcAbstractEntity* e) { entity = e; } -IfcBoolean::IfcBoolean(bool v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcBoolean); e->setArgument(0, v); entity = e; } -IfcBoolean::operator bool() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcBoolean::declaration() const { return *IfcBoolean_type; } +IfcBoolean::IfcBoolean(IfcAbstractEntity* e) { data_ = e; } +IfcBoolean::IfcBoolean(bool v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcBoolean); e->setArgument(0, v); data_ = e; } +IfcBoolean::operator bool() const { return *data_->getArgument(0); } // Function implementations for IfcBoxAlignment -IfcUtil::ArgumentType IfcBoxAlignment::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcBoxAlignment::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcBoxAlignment::is(Type::Enum v) const { return v == Type::IfcBoxAlignment || IfcLabel::is(v); } -Type::Enum IfcBoxAlignment::type() const { return Type::IfcBoxAlignment; } Type::Enum IfcBoxAlignment::Class() { return Type::IfcBoxAlignment; } -IfcBoxAlignment::IfcBoxAlignment(IfcAbstractEntity* e) : IfcLabel((IfcAbstractEntity*)0) { entity = e; } -IfcBoxAlignment::IfcBoxAlignment(std::string v) : IfcLabel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcBoxAlignment); e->setArgument(0, v); entity = e; } -IfcBoxAlignment::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcBoxAlignment::declaration() const { return *IfcBoxAlignment_type; } +IfcBoxAlignment::IfcBoxAlignment(IfcAbstractEntity* e) : IfcLabel((IfcAbstractEntity*)0) { data_ = e; } +IfcBoxAlignment::IfcBoxAlignment(std::string v) : IfcLabel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcBoxAlignment); e->setArgument(0, v); data_ = e; } +IfcBoxAlignment::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcComplexNumber -IfcUtil::ArgumentType IfcComplexNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcComplexNumber::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcComplexNumber::is(Type::Enum v) const { return v == IfcComplexNumber::Class(); } -Type::Enum IfcComplexNumber::type() const { return Type::IfcComplexNumber; } Type::Enum IfcComplexNumber::Class() { return Type::IfcComplexNumber; } -IfcComplexNumber::IfcComplexNumber(IfcAbstractEntity* e) { entity = e; } -IfcComplexNumber::IfcComplexNumber(std::vector< double > /*[1:2]*/ v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcComplexNumber); e->setArgument(0, v); entity = e; } -IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcComplexNumber::declaration() const { return *IfcComplexNumber_type; } +IfcComplexNumber::IfcComplexNumber(IfcAbstractEntity* e) { data_ = e; } +IfcComplexNumber::IfcComplexNumber(std::vector< double > /*[1:2]*/ v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcComplexNumber); e->setArgument(0, v); data_ = e; } +IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return *data_->getArgument(0); } // Function implementations for IfcCompoundPlaneAngleMeasure -IfcUtil::ArgumentType IfcCompoundPlaneAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcCompoundPlaneAngleMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcCompoundPlaneAngleMeasure::is(Type::Enum v) const { return v == IfcCompoundPlaneAngleMeasure::Class(); } -Type::Enum IfcCompoundPlaneAngleMeasure::type() const { return Type::IfcCompoundPlaneAngleMeasure; } Type::Enum IfcCompoundPlaneAngleMeasure::Class() { return Type::IfcCompoundPlaneAngleMeasure; } -IfcCompoundPlaneAngleMeasure::IfcCompoundPlaneAngleMeasure(IfcAbstractEntity* e) { entity = e; } -IfcCompoundPlaneAngleMeasure::IfcCompoundPlaneAngleMeasure(std::vector< int > /*[3:4]*/ v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcCompoundPlaneAngleMeasure); e->setArgument(0, v); entity = e; } -IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcCompoundPlaneAngleMeasure::declaration() const { return *IfcCompoundPlaneAngleMeasure_type; } +IfcCompoundPlaneAngleMeasure::IfcCompoundPlaneAngleMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcCompoundPlaneAngleMeasure::IfcCompoundPlaneAngleMeasure(std::vector< int > /*[3:4]*/ v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcCompoundPlaneAngleMeasure); e->setArgument(0, v); data_ = e; } +IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return *data_->getArgument(0); } // Function implementations for IfcContextDependentMeasure -IfcUtil::ArgumentType IfcContextDependentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcContextDependentMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcContextDependentMeasure::is(Type::Enum v) const { return v == IfcContextDependentMeasure::Class(); } -Type::Enum IfcContextDependentMeasure::type() const { return Type::IfcContextDependentMeasure; } Type::Enum IfcContextDependentMeasure::Class() { return Type::IfcContextDependentMeasure; } -IfcContextDependentMeasure::IfcContextDependentMeasure(IfcAbstractEntity* e) { entity = e; } -IfcContextDependentMeasure::IfcContextDependentMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcContextDependentMeasure); e->setArgument(0, v); entity = e; } -IfcContextDependentMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcContextDependentMeasure::declaration() const { return *IfcContextDependentMeasure_type; } +IfcContextDependentMeasure::IfcContextDependentMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcContextDependentMeasure::IfcContextDependentMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcContextDependentMeasure); e->setArgument(0, v); data_ = e; } +IfcContextDependentMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcCountMeasure -IfcUtil::ArgumentType IfcCountMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcCountMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcCountMeasure::is(Type::Enum v) const { return v == IfcCountMeasure::Class(); } -Type::Enum IfcCountMeasure::type() const { return Type::IfcCountMeasure; } Type::Enum IfcCountMeasure::Class() { return Type::IfcCountMeasure; } -IfcCountMeasure::IfcCountMeasure(IfcAbstractEntity* e) { entity = e; } -IfcCountMeasure::IfcCountMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcCountMeasure); e->setArgument(0, v); entity = e; } -IfcCountMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcCountMeasure::declaration() const { return *IfcCountMeasure_type; } +IfcCountMeasure::IfcCountMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcCountMeasure::IfcCountMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcCountMeasure); e->setArgument(0, v); data_ = e; } +IfcCountMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcCurvatureMeasure -IfcUtil::ArgumentType IfcCurvatureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcCurvatureMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcCurvatureMeasure::is(Type::Enum v) const { return v == IfcCurvatureMeasure::Class(); } -Type::Enum IfcCurvatureMeasure::type() const { return Type::IfcCurvatureMeasure; } Type::Enum IfcCurvatureMeasure::Class() { return Type::IfcCurvatureMeasure; } -IfcCurvatureMeasure::IfcCurvatureMeasure(IfcAbstractEntity* e) { entity = e; } -IfcCurvatureMeasure::IfcCurvatureMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcCurvatureMeasure); e->setArgument(0, v); entity = e; } -IfcCurvatureMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcCurvatureMeasure::declaration() const { return *IfcCurvatureMeasure_type; } +IfcCurvatureMeasure::IfcCurvatureMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcCurvatureMeasure::IfcCurvatureMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcCurvatureMeasure); e->setArgument(0, v); data_ = e; } +IfcCurvatureMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcDayInMonthNumber -IfcUtil::ArgumentType IfcDayInMonthNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcDayInMonthNumber::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcDayInMonthNumber::is(Type::Enum v) const { return v == IfcDayInMonthNumber::Class(); } -Type::Enum IfcDayInMonthNumber::type() const { return Type::IfcDayInMonthNumber; } Type::Enum IfcDayInMonthNumber::Class() { return Type::IfcDayInMonthNumber; } -IfcDayInMonthNumber::IfcDayInMonthNumber(IfcAbstractEntity* e) { entity = e; } -IfcDayInMonthNumber::IfcDayInMonthNumber(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDayInMonthNumber); e->setArgument(0, v); entity = e; } -IfcDayInMonthNumber::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcDayInMonthNumber::declaration() const { return *IfcDayInMonthNumber_type; } +IfcDayInMonthNumber::IfcDayInMonthNumber(IfcAbstractEntity* e) { data_ = e; } +IfcDayInMonthNumber::IfcDayInMonthNumber(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDayInMonthNumber); e->setArgument(0, v); data_ = e; } +IfcDayInMonthNumber::operator int() const { return *data_->getArgument(0); } // Function implementations for IfcDaylightSavingHour -IfcUtil::ArgumentType IfcDaylightSavingHour::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcDaylightSavingHour::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcDaylightSavingHour::is(Type::Enum v) const { return v == IfcDaylightSavingHour::Class(); } -Type::Enum IfcDaylightSavingHour::type() const { return Type::IfcDaylightSavingHour; } Type::Enum IfcDaylightSavingHour::Class() { return Type::IfcDaylightSavingHour; } -IfcDaylightSavingHour::IfcDaylightSavingHour(IfcAbstractEntity* e) { entity = e; } -IfcDaylightSavingHour::IfcDaylightSavingHour(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDaylightSavingHour); e->setArgument(0, v); entity = e; } -IfcDaylightSavingHour::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcDaylightSavingHour::declaration() const { return *IfcDaylightSavingHour_type; } +IfcDaylightSavingHour::IfcDaylightSavingHour(IfcAbstractEntity* e) { data_ = e; } +IfcDaylightSavingHour::IfcDaylightSavingHour(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDaylightSavingHour); e->setArgument(0, v); data_ = e; } +IfcDaylightSavingHour::operator int() const { return *data_->getArgument(0); } // Function implementations for IfcDescriptiveMeasure -IfcUtil::ArgumentType IfcDescriptiveMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcDescriptiveMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcDescriptiveMeasure::is(Type::Enum v) const { return v == IfcDescriptiveMeasure::Class(); } -Type::Enum IfcDescriptiveMeasure::type() const { return Type::IfcDescriptiveMeasure; } Type::Enum IfcDescriptiveMeasure::Class() { return Type::IfcDescriptiveMeasure; } -IfcDescriptiveMeasure::IfcDescriptiveMeasure(IfcAbstractEntity* e) { entity = e; } -IfcDescriptiveMeasure::IfcDescriptiveMeasure(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDescriptiveMeasure); e->setArgument(0, v); entity = e; } -IfcDescriptiveMeasure::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcDescriptiveMeasure::declaration() const { return *IfcDescriptiveMeasure_type; } +IfcDescriptiveMeasure::IfcDescriptiveMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcDescriptiveMeasure::IfcDescriptiveMeasure(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDescriptiveMeasure); e->setArgument(0, v); data_ = e; } +IfcDescriptiveMeasure::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcDimensionCount -IfcUtil::ArgumentType IfcDimensionCount::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcDimensionCount::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcDimensionCount::is(Type::Enum v) const { return v == IfcDimensionCount::Class(); } -Type::Enum IfcDimensionCount::type() const { return Type::IfcDimensionCount; } Type::Enum IfcDimensionCount::Class() { return Type::IfcDimensionCount; } -IfcDimensionCount::IfcDimensionCount(IfcAbstractEntity* e) { entity = e; } -IfcDimensionCount::IfcDimensionCount(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDimensionCount); e->setArgument(0, v); entity = e; } -IfcDimensionCount::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcDimensionCount::declaration() const { return *IfcDimensionCount_type; } +IfcDimensionCount::IfcDimensionCount(IfcAbstractEntity* e) { data_ = e; } +IfcDimensionCount::IfcDimensionCount(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDimensionCount); e->setArgument(0, v); data_ = e; } +IfcDimensionCount::operator int() const { return *data_->getArgument(0); } // Function implementations for IfcDoseEquivalentMeasure -IfcUtil::ArgumentType IfcDoseEquivalentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcDoseEquivalentMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcDoseEquivalentMeasure::is(Type::Enum v) const { return v == IfcDoseEquivalentMeasure::Class(); } -Type::Enum IfcDoseEquivalentMeasure::type() const { return Type::IfcDoseEquivalentMeasure; } Type::Enum IfcDoseEquivalentMeasure::Class() { return Type::IfcDoseEquivalentMeasure; } -IfcDoseEquivalentMeasure::IfcDoseEquivalentMeasure(IfcAbstractEntity* e) { entity = e; } -IfcDoseEquivalentMeasure::IfcDoseEquivalentMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDoseEquivalentMeasure); e->setArgument(0, v); entity = e; } -IfcDoseEquivalentMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcDoseEquivalentMeasure::declaration() const { return *IfcDoseEquivalentMeasure_type; } +IfcDoseEquivalentMeasure::IfcDoseEquivalentMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcDoseEquivalentMeasure::IfcDoseEquivalentMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDoseEquivalentMeasure); e->setArgument(0, v); data_ = e; } +IfcDoseEquivalentMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcDynamicViscosityMeasure -IfcUtil::ArgumentType IfcDynamicViscosityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcDynamicViscosityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcDynamicViscosityMeasure::is(Type::Enum v) const { return v == IfcDynamicViscosityMeasure::Class(); } -Type::Enum IfcDynamicViscosityMeasure::type() const { return Type::IfcDynamicViscosityMeasure; } Type::Enum IfcDynamicViscosityMeasure::Class() { return Type::IfcDynamicViscosityMeasure; } -IfcDynamicViscosityMeasure::IfcDynamicViscosityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcDynamicViscosityMeasure::IfcDynamicViscosityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDynamicViscosityMeasure); e->setArgument(0, v); entity = e; } -IfcDynamicViscosityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcDynamicViscosityMeasure::declaration() const { return *IfcDynamicViscosityMeasure_type; } +IfcDynamicViscosityMeasure::IfcDynamicViscosityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcDynamicViscosityMeasure::IfcDynamicViscosityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDynamicViscosityMeasure); e->setArgument(0, v); data_ = e; } +IfcDynamicViscosityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcElectricCapacitanceMeasure -IfcUtil::ArgumentType IfcElectricCapacitanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcElectricCapacitanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcElectricCapacitanceMeasure::is(Type::Enum v) const { return v == IfcElectricCapacitanceMeasure::Class(); } -Type::Enum IfcElectricCapacitanceMeasure::type() const { return Type::IfcElectricCapacitanceMeasure; } Type::Enum IfcElectricCapacitanceMeasure::Class() { return Type::IfcElectricCapacitanceMeasure; } -IfcElectricCapacitanceMeasure::IfcElectricCapacitanceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcElectricCapacitanceMeasure::IfcElectricCapacitanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricCapacitanceMeasure); e->setArgument(0, v); entity = e; } -IfcElectricCapacitanceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcElectricCapacitanceMeasure::declaration() const { return *IfcElectricCapacitanceMeasure_type; } +IfcElectricCapacitanceMeasure::IfcElectricCapacitanceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcElectricCapacitanceMeasure::IfcElectricCapacitanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricCapacitanceMeasure); e->setArgument(0, v); data_ = e; } +IfcElectricCapacitanceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcElectricChargeMeasure -IfcUtil::ArgumentType IfcElectricChargeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcElectricChargeMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcElectricChargeMeasure::is(Type::Enum v) const { return v == IfcElectricChargeMeasure::Class(); } -Type::Enum IfcElectricChargeMeasure::type() const { return Type::IfcElectricChargeMeasure; } Type::Enum IfcElectricChargeMeasure::Class() { return Type::IfcElectricChargeMeasure; } -IfcElectricChargeMeasure::IfcElectricChargeMeasure(IfcAbstractEntity* e) { entity = e; } -IfcElectricChargeMeasure::IfcElectricChargeMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricChargeMeasure); e->setArgument(0, v); entity = e; } -IfcElectricChargeMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcElectricChargeMeasure::declaration() const { return *IfcElectricChargeMeasure_type; } +IfcElectricChargeMeasure::IfcElectricChargeMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcElectricChargeMeasure::IfcElectricChargeMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricChargeMeasure); e->setArgument(0, v); data_ = e; } +IfcElectricChargeMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcElectricConductanceMeasure -IfcUtil::ArgumentType IfcElectricConductanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcElectricConductanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcElectricConductanceMeasure::is(Type::Enum v) const { return v == IfcElectricConductanceMeasure::Class(); } -Type::Enum IfcElectricConductanceMeasure::type() const { return Type::IfcElectricConductanceMeasure; } Type::Enum IfcElectricConductanceMeasure::Class() { return Type::IfcElectricConductanceMeasure; } -IfcElectricConductanceMeasure::IfcElectricConductanceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcElectricConductanceMeasure::IfcElectricConductanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricConductanceMeasure); e->setArgument(0, v); entity = e; } -IfcElectricConductanceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcElectricConductanceMeasure::declaration() const { return *IfcElectricConductanceMeasure_type; } +IfcElectricConductanceMeasure::IfcElectricConductanceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcElectricConductanceMeasure::IfcElectricConductanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricConductanceMeasure); e->setArgument(0, v); data_ = e; } +IfcElectricConductanceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcElectricCurrentMeasure -IfcUtil::ArgumentType IfcElectricCurrentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcElectricCurrentMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcElectricCurrentMeasure::is(Type::Enum v) const { return v == IfcElectricCurrentMeasure::Class(); } -Type::Enum IfcElectricCurrentMeasure::type() const { return Type::IfcElectricCurrentMeasure; } Type::Enum IfcElectricCurrentMeasure::Class() { return Type::IfcElectricCurrentMeasure; } -IfcElectricCurrentMeasure::IfcElectricCurrentMeasure(IfcAbstractEntity* e) { entity = e; } -IfcElectricCurrentMeasure::IfcElectricCurrentMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricCurrentMeasure); e->setArgument(0, v); entity = e; } -IfcElectricCurrentMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcElectricCurrentMeasure::declaration() const { return *IfcElectricCurrentMeasure_type; } +IfcElectricCurrentMeasure::IfcElectricCurrentMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcElectricCurrentMeasure::IfcElectricCurrentMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricCurrentMeasure); e->setArgument(0, v); data_ = e; } +IfcElectricCurrentMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcElectricResistanceMeasure -IfcUtil::ArgumentType IfcElectricResistanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcElectricResistanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcElectricResistanceMeasure::is(Type::Enum v) const { return v == IfcElectricResistanceMeasure::Class(); } -Type::Enum IfcElectricResistanceMeasure::type() const { return Type::IfcElectricResistanceMeasure; } Type::Enum IfcElectricResistanceMeasure::Class() { return Type::IfcElectricResistanceMeasure; } -IfcElectricResistanceMeasure::IfcElectricResistanceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcElectricResistanceMeasure::IfcElectricResistanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricResistanceMeasure); e->setArgument(0, v); entity = e; } -IfcElectricResistanceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcElectricResistanceMeasure::declaration() const { return *IfcElectricResistanceMeasure_type; } +IfcElectricResistanceMeasure::IfcElectricResistanceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcElectricResistanceMeasure::IfcElectricResistanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricResistanceMeasure); e->setArgument(0, v); data_ = e; } +IfcElectricResistanceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcElectricVoltageMeasure -IfcUtil::ArgumentType IfcElectricVoltageMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcElectricVoltageMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcElectricVoltageMeasure::is(Type::Enum v) const { return v == IfcElectricVoltageMeasure::Class(); } -Type::Enum IfcElectricVoltageMeasure::type() const { return Type::IfcElectricVoltageMeasure; } Type::Enum IfcElectricVoltageMeasure::Class() { return Type::IfcElectricVoltageMeasure; } -IfcElectricVoltageMeasure::IfcElectricVoltageMeasure(IfcAbstractEntity* e) { entity = e; } -IfcElectricVoltageMeasure::IfcElectricVoltageMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricVoltageMeasure); e->setArgument(0, v); entity = e; } -IfcElectricVoltageMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcElectricVoltageMeasure::declaration() const { return *IfcElectricVoltageMeasure_type; } +IfcElectricVoltageMeasure::IfcElectricVoltageMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcElectricVoltageMeasure::IfcElectricVoltageMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcElectricVoltageMeasure); e->setArgument(0, v); data_ = e; } +IfcElectricVoltageMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcEnergyMeasure -IfcUtil::ArgumentType IfcEnergyMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcEnergyMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcEnergyMeasure::is(Type::Enum v) const { return v == IfcEnergyMeasure::Class(); } -Type::Enum IfcEnergyMeasure::type() const { return Type::IfcEnergyMeasure; } Type::Enum IfcEnergyMeasure::Class() { return Type::IfcEnergyMeasure; } -IfcEnergyMeasure::IfcEnergyMeasure(IfcAbstractEntity* e) { entity = e; } -IfcEnergyMeasure::IfcEnergyMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcEnergyMeasure); e->setArgument(0, v); entity = e; } -IfcEnergyMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcEnergyMeasure::declaration() const { return *IfcEnergyMeasure_type; } +IfcEnergyMeasure::IfcEnergyMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcEnergyMeasure::IfcEnergyMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcEnergyMeasure); e->setArgument(0, v); data_ = e; } +IfcEnergyMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcFontStyle -IfcUtil::ArgumentType IfcFontStyle::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcFontStyle::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcFontStyle::is(Type::Enum v) const { return v == IfcFontStyle::Class(); } -Type::Enum IfcFontStyle::type() const { return Type::IfcFontStyle; } Type::Enum IfcFontStyle::Class() { return Type::IfcFontStyle; } -IfcFontStyle::IfcFontStyle(IfcAbstractEntity* e) { entity = e; } -IfcFontStyle::IfcFontStyle(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcFontStyle); e->setArgument(0, v); entity = e; } -IfcFontStyle::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcFontStyle::declaration() const { return *IfcFontStyle_type; } +IfcFontStyle::IfcFontStyle(IfcAbstractEntity* e) { data_ = e; } +IfcFontStyle::IfcFontStyle(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcFontStyle); e->setArgument(0, v); data_ = e; } +IfcFontStyle::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcFontVariant -IfcUtil::ArgumentType IfcFontVariant::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcFontVariant::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcFontVariant::is(Type::Enum v) const { return v == IfcFontVariant::Class(); } -Type::Enum IfcFontVariant::type() const { return Type::IfcFontVariant; } Type::Enum IfcFontVariant::Class() { return Type::IfcFontVariant; } -IfcFontVariant::IfcFontVariant(IfcAbstractEntity* e) { entity = e; } -IfcFontVariant::IfcFontVariant(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcFontVariant); e->setArgument(0, v); entity = e; } -IfcFontVariant::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcFontVariant::declaration() const { return *IfcFontVariant_type; } +IfcFontVariant::IfcFontVariant(IfcAbstractEntity* e) { data_ = e; } +IfcFontVariant::IfcFontVariant(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcFontVariant); e->setArgument(0, v); data_ = e; } +IfcFontVariant::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcFontWeight -IfcUtil::ArgumentType IfcFontWeight::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcFontWeight::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcFontWeight::is(Type::Enum v) const { return v == IfcFontWeight::Class(); } -Type::Enum IfcFontWeight::type() const { return Type::IfcFontWeight; } Type::Enum IfcFontWeight::Class() { return Type::IfcFontWeight; } -IfcFontWeight::IfcFontWeight(IfcAbstractEntity* e) { entity = e; } -IfcFontWeight::IfcFontWeight(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcFontWeight); e->setArgument(0, v); entity = e; } -IfcFontWeight::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcFontWeight::declaration() const { return *IfcFontWeight_type; } +IfcFontWeight::IfcFontWeight(IfcAbstractEntity* e) { data_ = e; } +IfcFontWeight::IfcFontWeight(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcFontWeight); e->setArgument(0, v); data_ = e; } +IfcFontWeight::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcForceMeasure -IfcUtil::ArgumentType IfcForceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcForceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcForceMeasure::is(Type::Enum v) const { return v == IfcForceMeasure::Class(); } -Type::Enum IfcForceMeasure::type() const { return Type::IfcForceMeasure; } Type::Enum IfcForceMeasure::Class() { return Type::IfcForceMeasure; } -IfcForceMeasure::IfcForceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcForceMeasure::IfcForceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcForceMeasure); e->setArgument(0, v); entity = e; } -IfcForceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcForceMeasure::declaration() const { return *IfcForceMeasure_type; } +IfcForceMeasure::IfcForceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcForceMeasure::IfcForceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcForceMeasure); e->setArgument(0, v); data_ = e; } +IfcForceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcFrequencyMeasure -IfcUtil::ArgumentType IfcFrequencyMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcFrequencyMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcFrequencyMeasure::is(Type::Enum v) const { return v == IfcFrequencyMeasure::Class(); } -Type::Enum IfcFrequencyMeasure::type() const { return Type::IfcFrequencyMeasure; } Type::Enum IfcFrequencyMeasure::Class() { return Type::IfcFrequencyMeasure; } -IfcFrequencyMeasure::IfcFrequencyMeasure(IfcAbstractEntity* e) { entity = e; } -IfcFrequencyMeasure::IfcFrequencyMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcFrequencyMeasure); e->setArgument(0, v); entity = e; } -IfcFrequencyMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcFrequencyMeasure::declaration() const { return *IfcFrequencyMeasure_type; } +IfcFrequencyMeasure::IfcFrequencyMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcFrequencyMeasure::IfcFrequencyMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcFrequencyMeasure); e->setArgument(0, v); data_ = e; } +IfcFrequencyMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcGloballyUniqueId -IfcUtil::ArgumentType IfcGloballyUniqueId::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcGloballyUniqueId::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcGloballyUniqueId::is(Type::Enum v) const { return v == IfcGloballyUniqueId::Class(); } -Type::Enum IfcGloballyUniqueId::type() const { return Type::IfcGloballyUniqueId; } Type::Enum IfcGloballyUniqueId::Class() { return Type::IfcGloballyUniqueId; } -IfcGloballyUniqueId::IfcGloballyUniqueId(IfcAbstractEntity* e) { entity = e; } -IfcGloballyUniqueId::IfcGloballyUniqueId(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcGloballyUniqueId); e->setArgument(0, v); entity = e; } -IfcGloballyUniqueId::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcGloballyUniqueId::declaration() const { return *IfcGloballyUniqueId_type; } +IfcGloballyUniqueId::IfcGloballyUniqueId(IfcAbstractEntity* e) { data_ = e; } +IfcGloballyUniqueId::IfcGloballyUniqueId(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcGloballyUniqueId); e->setArgument(0, v); data_ = e; } +IfcGloballyUniqueId::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcHeatFluxDensityMeasure -IfcUtil::ArgumentType IfcHeatFluxDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcHeatFluxDensityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcHeatFluxDensityMeasure::is(Type::Enum v) const { return v == IfcHeatFluxDensityMeasure::Class(); } -Type::Enum IfcHeatFluxDensityMeasure::type() const { return Type::IfcHeatFluxDensityMeasure; } Type::Enum IfcHeatFluxDensityMeasure::Class() { return Type::IfcHeatFluxDensityMeasure; } -IfcHeatFluxDensityMeasure::IfcHeatFluxDensityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcHeatFluxDensityMeasure::IfcHeatFluxDensityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcHeatFluxDensityMeasure); e->setArgument(0, v); entity = e; } -IfcHeatFluxDensityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcHeatFluxDensityMeasure::declaration() const { return *IfcHeatFluxDensityMeasure_type; } +IfcHeatFluxDensityMeasure::IfcHeatFluxDensityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcHeatFluxDensityMeasure::IfcHeatFluxDensityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcHeatFluxDensityMeasure); e->setArgument(0, v); data_ = e; } +IfcHeatFluxDensityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcHeatingValueMeasure -IfcUtil::ArgumentType IfcHeatingValueMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcHeatingValueMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcHeatingValueMeasure::is(Type::Enum v) const { return v == IfcHeatingValueMeasure::Class(); } -Type::Enum IfcHeatingValueMeasure::type() const { return Type::IfcHeatingValueMeasure; } Type::Enum IfcHeatingValueMeasure::Class() { return Type::IfcHeatingValueMeasure; } -IfcHeatingValueMeasure::IfcHeatingValueMeasure(IfcAbstractEntity* e) { entity = e; } -IfcHeatingValueMeasure::IfcHeatingValueMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcHeatingValueMeasure); e->setArgument(0, v); entity = e; } -IfcHeatingValueMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcHeatingValueMeasure::declaration() const { return *IfcHeatingValueMeasure_type; } +IfcHeatingValueMeasure::IfcHeatingValueMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcHeatingValueMeasure::IfcHeatingValueMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcHeatingValueMeasure); e->setArgument(0, v); data_ = e; } +IfcHeatingValueMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcHourInDay -IfcUtil::ArgumentType IfcHourInDay::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcHourInDay::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcHourInDay::is(Type::Enum v) const { return v == IfcHourInDay::Class(); } -Type::Enum IfcHourInDay::type() const { return Type::IfcHourInDay; } Type::Enum IfcHourInDay::Class() { return Type::IfcHourInDay; } -IfcHourInDay::IfcHourInDay(IfcAbstractEntity* e) { entity = e; } -IfcHourInDay::IfcHourInDay(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcHourInDay); e->setArgument(0, v); entity = e; } -IfcHourInDay::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcHourInDay::declaration() const { return *IfcHourInDay_type; } +IfcHourInDay::IfcHourInDay(IfcAbstractEntity* e) { data_ = e; } +IfcHourInDay::IfcHourInDay(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcHourInDay); e->setArgument(0, v); data_ = e; } +IfcHourInDay::operator int() const { return *data_->getArgument(0); } // Function implementations for IfcIdentifier -IfcUtil::ArgumentType IfcIdentifier::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcIdentifier::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcIdentifier::is(Type::Enum v) const { return v == IfcIdentifier::Class(); } -Type::Enum IfcIdentifier::type() const { return Type::IfcIdentifier; } Type::Enum IfcIdentifier::Class() { return Type::IfcIdentifier; } -IfcIdentifier::IfcIdentifier(IfcAbstractEntity* e) { entity = e; } -IfcIdentifier::IfcIdentifier(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcIdentifier); e->setArgument(0, v); entity = e; } -IfcIdentifier::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcIdentifier::declaration() const { return *IfcIdentifier_type; } +IfcIdentifier::IfcIdentifier(IfcAbstractEntity* e) { data_ = e; } +IfcIdentifier::IfcIdentifier(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcIdentifier); e->setArgument(0, v); data_ = e; } +IfcIdentifier::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcIlluminanceMeasure -IfcUtil::ArgumentType IfcIlluminanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcIlluminanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcIlluminanceMeasure::is(Type::Enum v) const { return v == IfcIlluminanceMeasure::Class(); } -Type::Enum IfcIlluminanceMeasure::type() const { return Type::IfcIlluminanceMeasure; } Type::Enum IfcIlluminanceMeasure::Class() { return Type::IfcIlluminanceMeasure; } -IfcIlluminanceMeasure::IfcIlluminanceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcIlluminanceMeasure::IfcIlluminanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcIlluminanceMeasure); e->setArgument(0, v); entity = e; } -IfcIlluminanceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcIlluminanceMeasure::declaration() const { return *IfcIlluminanceMeasure_type; } +IfcIlluminanceMeasure::IfcIlluminanceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcIlluminanceMeasure::IfcIlluminanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcIlluminanceMeasure); e->setArgument(0, v); data_ = e; } +IfcIlluminanceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcInductanceMeasure -IfcUtil::ArgumentType IfcInductanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcInductanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcInductanceMeasure::is(Type::Enum v) const { return v == IfcInductanceMeasure::Class(); } -Type::Enum IfcInductanceMeasure::type() const { return Type::IfcInductanceMeasure; } Type::Enum IfcInductanceMeasure::Class() { return Type::IfcInductanceMeasure; } -IfcInductanceMeasure::IfcInductanceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcInductanceMeasure::IfcInductanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcInductanceMeasure); e->setArgument(0, v); entity = e; } -IfcInductanceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcInductanceMeasure::declaration() const { return *IfcInductanceMeasure_type; } +IfcInductanceMeasure::IfcInductanceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcInductanceMeasure::IfcInductanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcInductanceMeasure); e->setArgument(0, v); data_ = e; } +IfcInductanceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcInteger -IfcUtil::ArgumentType IfcInteger::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcInteger::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcInteger::is(Type::Enum v) const { return v == IfcInteger::Class(); } -Type::Enum IfcInteger::type() const { return Type::IfcInteger; } Type::Enum IfcInteger::Class() { return Type::IfcInteger; } -IfcInteger::IfcInteger(IfcAbstractEntity* e) { entity = e; } -IfcInteger::IfcInteger(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcInteger); e->setArgument(0, v); entity = e; } -IfcInteger::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcInteger::declaration() const { return *IfcInteger_type; } +IfcInteger::IfcInteger(IfcAbstractEntity* e) { data_ = e; } +IfcInteger::IfcInteger(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcInteger); e->setArgument(0, v); data_ = e; } +IfcInteger::operator int() const { return *data_->getArgument(0); } // Function implementations for IfcIntegerCountRateMeasure -IfcUtil::ArgumentType IfcIntegerCountRateMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcIntegerCountRateMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcIntegerCountRateMeasure::is(Type::Enum v) const { return v == IfcIntegerCountRateMeasure::Class(); } -Type::Enum IfcIntegerCountRateMeasure::type() const { return Type::IfcIntegerCountRateMeasure; } Type::Enum IfcIntegerCountRateMeasure::Class() { return Type::IfcIntegerCountRateMeasure; } -IfcIntegerCountRateMeasure::IfcIntegerCountRateMeasure(IfcAbstractEntity* e) { entity = e; } -IfcIntegerCountRateMeasure::IfcIntegerCountRateMeasure(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcIntegerCountRateMeasure); e->setArgument(0, v); entity = e; } -IfcIntegerCountRateMeasure::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcIntegerCountRateMeasure::declaration() const { return *IfcIntegerCountRateMeasure_type; } +IfcIntegerCountRateMeasure::IfcIntegerCountRateMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcIntegerCountRateMeasure::IfcIntegerCountRateMeasure(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcIntegerCountRateMeasure); e->setArgument(0, v); data_ = e; } +IfcIntegerCountRateMeasure::operator int() const { return *data_->getArgument(0); } // Function implementations for IfcIonConcentrationMeasure -IfcUtil::ArgumentType IfcIonConcentrationMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcIonConcentrationMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcIonConcentrationMeasure::is(Type::Enum v) const { return v == IfcIonConcentrationMeasure::Class(); } -Type::Enum IfcIonConcentrationMeasure::type() const { return Type::IfcIonConcentrationMeasure; } Type::Enum IfcIonConcentrationMeasure::Class() { return Type::IfcIonConcentrationMeasure; } -IfcIonConcentrationMeasure::IfcIonConcentrationMeasure(IfcAbstractEntity* e) { entity = e; } -IfcIonConcentrationMeasure::IfcIonConcentrationMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcIonConcentrationMeasure); e->setArgument(0, v); entity = e; } -IfcIonConcentrationMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcIonConcentrationMeasure::declaration() const { return *IfcIonConcentrationMeasure_type; } +IfcIonConcentrationMeasure::IfcIonConcentrationMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcIonConcentrationMeasure::IfcIonConcentrationMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcIonConcentrationMeasure); e->setArgument(0, v); data_ = e; } +IfcIonConcentrationMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcIsothermalMoistureCapacityMeasure -IfcUtil::ArgumentType IfcIsothermalMoistureCapacityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcIsothermalMoistureCapacityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcIsothermalMoistureCapacityMeasure::is(Type::Enum v) const { return v == IfcIsothermalMoistureCapacityMeasure::Class(); } -Type::Enum IfcIsothermalMoistureCapacityMeasure::type() const { return Type::IfcIsothermalMoistureCapacityMeasure; } Type::Enum IfcIsothermalMoistureCapacityMeasure::Class() { return Type::IfcIsothermalMoistureCapacityMeasure; } -IfcIsothermalMoistureCapacityMeasure::IfcIsothermalMoistureCapacityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcIsothermalMoistureCapacityMeasure::IfcIsothermalMoistureCapacityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcIsothermalMoistureCapacityMeasure); e->setArgument(0, v); entity = e; } -IfcIsothermalMoistureCapacityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcIsothermalMoistureCapacityMeasure::declaration() const { return *IfcIsothermalMoistureCapacityMeasure_type; } +IfcIsothermalMoistureCapacityMeasure::IfcIsothermalMoistureCapacityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcIsothermalMoistureCapacityMeasure::IfcIsothermalMoistureCapacityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcIsothermalMoistureCapacityMeasure); e->setArgument(0, v); data_ = e; } +IfcIsothermalMoistureCapacityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcKinematicViscosityMeasure -IfcUtil::ArgumentType IfcKinematicViscosityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcKinematicViscosityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcKinematicViscosityMeasure::is(Type::Enum v) const { return v == IfcKinematicViscosityMeasure::Class(); } -Type::Enum IfcKinematicViscosityMeasure::type() const { return Type::IfcKinematicViscosityMeasure; } Type::Enum IfcKinematicViscosityMeasure::Class() { return Type::IfcKinematicViscosityMeasure; } -IfcKinematicViscosityMeasure::IfcKinematicViscosityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcKinematicViscosityMeasure::IfcKinematicViscosityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcKinematicViscosityMeasure); e->setArgument(0, v); entity = e; } -IfcKinematicViscosityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcKinematicViscosityMeasure::declaration() const { return *IfcKinematicViscosityMeasure_type; } +IfcKinematicViscosityMeasure::IfcKinematicViscosityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcKinematicViscosityMeasure::IfcKinematicViscosityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcKinematicViscosityMeasure); e->setArgument(0, v); data_ = e; } +IfcKinematicViscosityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcLabel -IfcUtil::ArgumentType IfcLabel::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcLabel::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcLabel::is(Type::Enum v) const { return v == IfcLabel::Class(); } -Type::Enum IfcLabel::type() const { return Type::IfcLabel; } Type::Enum IfcLabel::Class() { return Type::IfcLabel; } -IfcLabel::IfcLabel(IfcAbstractEntity* e) { entity = e; } -IfcLabel::IfcLabel(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLabel); e->setArgument(0, v); entity = e; } -IfcLabel::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcLabel::declaration() const { return *IfcLabel_type; } +IfcLabel::IfcLabel(IfcAbstractEntity* e) { data_ = e; } +IfcLabel::IfcLabel(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLabel); e->setArgument(0, v); data_ = e; } +IfcLabel::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcLengthMeasure -IfcUtil::ArgumentType IfcLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcLengthMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcLengthMeasure::is(Type::Enum v) const { return v == IfcLengthMeasure::Class(); } -Type::Enum IfcLengthMeasure::type() const { return Type::IfcLengthMeasure; } Type::Enum IfcLengthMeasure::Class() { return Type::IfcLengthMeasure; } -IfcLengthMeasure::IfcLengthMeasure(IfcAbstractEntity* e) { entity = e; } -IfcLengthMeasure::IfcLengthMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLengthMeasure); e->setArgument(0, v); entity = e; } -IfcLengthMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcLengthMeasure::declaration() const { return *IfcLengthMeasure_type; } +IfcLengthMeasure::IfcLengthMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcLengthMeasure::IfcLengthMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLengthMeasure); e->setArgument(0, v); data_ = e; } +IfcLengthMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcLinearForceMeasure -IfcUtil::ArgumentType IfcLinearForceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcLinearForceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcLinearForceMeasure::is(Type::Enum v) const { return v == IfcLinearForceMeasure::Class(); } -Type::Enum IfcLinearForceMeasure::type() const { return Type::IfcLinearForceMeasure; } Type::Enum IfcLinearForceMeasure::Class() { return Type::IfcLinearForceMeasure; } -IfcLinearForceMeasure::IfcLinearForceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcLinearForceMeasure::IfcLinearForceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLinearForceMeasure); e->setArgument(0, v); entity = e; } -IfcLinearForceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcLinearForceMeasure::declaration() const { return *IfcLinearForceMeasure_type; } +IfcLinearForceMeasure::IfcLinearForceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcLinearForceMeasure::IfcLinearForceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLinearForceMeasure); e->setArgument(0, v); data_ = e; } +IfcLinearForceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcLinearMomentMeasure -IfcUtil::ArgumentType IfcLinearMomentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcLinearMomentMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcLinearMomentMeasure::is(Type::Enum v) const { return v == IfcLinearMomentMeasure::Class(); } -Type::Enum IfcLinearMomentMeasure::type() const { return Type::IfcLinearMomentMeasure; } Type::Enum IfcLinearMomentMeasure::Class() { return Type::IfcLinearMomentMeasure; } -IfcLinearMomentMeasure::IfcLinearMomentMeasure(IfcAbstractEntity* e) { entity = e; } -IfcLinearMomentMeasure::IfcLinearMomentMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLinearMomentMeasure); e->setArgument(0, v); entity = e; } -IfcLinearMomentMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcLinearMomentMeasure::declaration() const { return *IfcLinearMomentMeasure_type; } +IfcLinearMomentMeasure::IfcLinearMomentMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcLinearMomentMeasure::IfcLinearMomentMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLinearMomentMeasure); e->setArgument(0, v); data_ = e; } +IfcLinearMomentMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcLinearStiffnessMeasure -IfcUtil::ArgumentType IfcLinearStiffnessMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcLinearStiffnessMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcLinearStiffnessMeasure::is(Type::Enum v) const { return v == IfcLinearStiffnessMeasure::Class(); } -Type::Enum IfcLinearStiffnessMeasure::type() const { return Type::IfcLinearStiffnessMeasure; } Type::Enum IfcLinearStiffnessMeasure::Class() { return Type::IfcLinearStiffnessMeasure; } -IfcLinearStiffnessMeasure::IfcLinearStiffnessMeasure(IfcAbstractEntity* e) { entity = e; } -IfcLinearStiffnessMeasure::IfcLinearStiffnessMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLinearStiffnessMeasure); e->setArgument(0, v); entity = e; } -IfcLinearStiffnessMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcLinearStiffnessMeasure::declaration() const { return *IfcLinearStiffnessMeasure_type; } +IfcLinearStiffnessMeasure::IfcLinearStiffnessMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcLinearStiffnessMeasure::IfcLinearStiffnessMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLinearStiffnessMeasure); e->setArgument(0, v); data_ = e; } +IfcLinearStiffnessMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcLinearVelocityMeasure -IfcUtil::ArgumentType IfcLinearVelocityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcLinearVelocityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcLinearVelocityMeasure::is(Type::Enum v) const { return v == IfcLinearVelocityMeasure::Class(); } -Type::Enum IfcLinearVelocityMeasure::type() const { return Type::IfcLinearVelocityMeasure; } Type::Enum IfcLinearVelocityMeasure::Class() { return Type::IfcLinearVelocityMeasure; } -IfcLinearVelocityMeasure::IfcLinearVelocityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcLinearVelocityMeasure::IfcLinearVelocityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLinearVelocityMeasure); e->setArgument(0, v); entity = e; } -IfcLinearVelocityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcLinearVelocityMeasure::declaration() const { return *IfcLinearVelocityMeasure_type; } +IfcLinearVelocityMeasure::IfcLinearVelocityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcLinearVelocityMeasure::IfcLinearVelocityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLinearVelocityMeasure); e->setArgument(0, v); data_ = e; } +IfcLinearVelocityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcLogical -IfcUtil::ArgumentType IfcLogical::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_BOOL; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcLogical::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcLogical::is(Type::Enum v) const { return v == IfcLogical::Class(); } -Type::Enum IfcLogical::type() const { return Type::IfcLogical; } Type::Enum IfcLogical::Class() { return Type::IfcLogical; } -IfcLogical::IfcLogical(IfcAbstractEntity* e) { entity = e; } -IfcLogical::IfcLogical(bool v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLogical); e->setArgument(0, v); entity = e; } -IfcLogical::operator bool() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcLogical::declaration() const { return *IfcLogical_type; } +IfcLogical::IfcLogical(IfcAbstractEntity* e) { data_ = e; } +IfcLogical::IfcLogical(bool v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLogical); e->setArgument(0, v); data_ = e; } +IfcLogical::operator bool() const { return *data_->getArgument(0); } // Function implementations for IfcLuminousFluxMeasure -IfcUtil::ArgumentType IfcLuminousFluxMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcLuminousFluxMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcLuminousFluxMeasure::is(Type::Enum v) const { return v == IfcLuminousFluxMeasure::Class(); } -Type::Enum IfcLuminousFluxMeasure::type() const { return Type::IfcLuminousFluxMeasure; } Type::Enum IfcLuminousFluxMeasure::Class() { return Type::IfcLuminousFluxMeasure; } -IfcLuminousFluxMeasure::IfcLuminousFluxMeasure(IfcAbstractEntity* e) { entity = e; } -IfcLuminousFluxMeasure::IfcLuminousFluxMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLuminousFluxMeasure); e->setArgument(0, v); entity = e; } -IfcLuminousFluxMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcLuminousFluxMeasure::declaration() const { return *IfcLuminousFluxMeasure_type; } +IfcLuminousFluxMeasure::IfcLuminousFluxMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcLuminousFluxMeasure::IfcLuminousFluxMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLuminousFluxMeasure); e->setArgument(0, v); data_ = e; } +IfcLuminousFluxMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcLuminousIntensityDistributionMeasure -IfcUtil::ArgumentType IfcLuminousIntensityDistributionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcLuminousIntensityDistributionMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcLuminousIntensityDistributionMeasure::is(Type::Enum v) const { return v == IfcLuminousIntensityDistributionMeasure::Class(); } -Type::Enum IfcLuminousIntensityDistributionMeasure::type() const { return Type::IfcLuminousIntensityDistributionMeasure; } Type::Enum IfcLuminousIntensityDistributionMeasure::Class() { return Type::IfcLuminousIntensityDistributionMeasure; } -IfcLuminousIntensityDistributionMeasure::IfcLuminousIntensityDistributionMeasure(IfcAbstractEntity* e) { entity = e; } -IfcLuminousIntensityDistributionMeasure::IfcLuminousIntensityDistributionMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLuminousIntensityDistributionMeasure); e->setArgument(0, v); entity = e; } -IfcLuminousIntensityDistributionMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcLuminousIntensityDistributionMeasure::declaration() const { return *IfcLuminousIntensityDistributionMeasure_type; } +IfcLuminousIntensityDistributionMeasure::IfcLuminousIntensityDistributionMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcLuminousIntensityDistributionMeasure::IfcLuminousIntensityDistributionMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLuminousIntensityDistributionMeasure); e->setArgument(0, v); data_ = e; } +IfcLuminousIntensityDistributionMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcLuminousIntensityMeasure -IfcUtil::ArgumentType IfcLuminousIntensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcLuminousIntensityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcLuminousIntensityMeasure::is(Type::Enum v) const { return v == IfcLuminousIntensityMeasure::Class(); } -Type::Enum IfcLuminousIntensityMeasure::type() const { return Type::IfcLuminousIntensityMeasure; } Type::Enum IfcLuminousIntensityMeasure::Class() { return Type::IfcLuminousIntensityMeasure; } -IfcLuminousIntensityMeasure::IfcLuminousIntensityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcLuminousIntensityMeasure::IfcLuminousIntensityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLuminousIntensityMeasure); e->setArgument(0, v); entity = e; } -IfcLuminousIntensityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcLuminousIntensityMeasure::declaration() const { return *IfcLuminousIntensityMeasure_type; } +IfcLuminousIntensityMeasure::IfcLuminousIntensityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcLuminousIntensityMeasure::IfcLuminousIntensityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLuminousIntensityMeasure); e->setArgument(0, v); data_ = e; } +IfcLuminousIntensityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMagneticFluxDensityMeasure -IfcUtil::ArgumentType IfcMagneticFluxDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMagneticFluxDensityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMagneticFluxDensityMeasure::is(Type::Enum v) const { return v == IfcMagneticFluxDensityMeasure::Class(); } -Type::Enum IfcMagneticFluxDensityMeasure::type() const { return Type::IfcMagneticFluxDensityMeasure; } Type::Enum IfcMagneticFluxDensityMeasure::Class() { return Type::IfcMagneticFluxDensityMeasure; } -IfcMagneticFluxDensityMeasure::IfcMagneticFluxDensityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcMagneticFluxDensityMeasure::IfcMagneticFluxDensityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMagneticFluxDensityMeasure); e->setArgument(0, v); entity = e; } -IfcMagneticFluxDensityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMagneticFluxDensityMeasure::declaration() const { return *IfcMagneticFluxDensityMeasure_type; } +IfcMagneticFluxDensityMeasure::IfcMagneticFluxDensityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcMagneticFluxDensityMeasure::IfcMagneticFluxDensityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMagneticFluxDensityMeasure); e->setArgument(0, v); data_ = e; } +IfcMagneticFluxDensityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMagneticFluxMeasure -IfcUtil::ArgumentType IfcMagneticFluxMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMagneticFluxMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMagneticFluxMeasure::is(Type::Enum v) const { return v == IfcMagneticFluxMeasure::Class(); } -Type::Enum IfcMagneticFluxMeasure::type() const { return Type::IfcMagneticFluxMeasure; } Type::Enum IfcMagneticFluxMeasure::Class() { return Type::IfcMagneticFluxMeasure; } -IfcMagneticFluxMeasure::IfcMagneticFluxMeasure(IfcAbstractEntity* e) { entity = e; } -IfcMagneticFluxMeasure::IfcMagneticFluxMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMagneticFluxMeasure); e->setArgument(0, v); entity = e; } -IfcMagneticFluxMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMagneticFluxMeasure::declaration() const { return *IfcMagneticFluxMeasure_type; } +IfcMagneticFluxMeasure::IfcMagneticFluxMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcMagneticFluxMeasure::IfcMagneticFluxMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMagneticFluxMeasure); e->setArgument(0, v); data_ = e; } +IfcMagneticFluxMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMassDensityMeasure -IfcUtil::ArgumentType IfcMassDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMassDensityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMassDensityMeasure::is(Type::Enum v) const { return v == IfcMassDensityMeasure::Class(); } -Type::Enum IfcMassDensityMeasure::type() const { return Type::IfcMassDensityMeasure; } Type::Enum IfcMassDensityMeasure::Class() { return Type::IfcMassDensityMeasure; } -IfcMassDensityMeasure::IfcMassDensityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcMassDensityMeasure::IfcMassDensityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMassDensityMeasure); e->setArgument(0, v); entity = e; } -IfcMassDensityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMassDensityMeasure::declaration() const { return *IfcMassDensityMeasure_type; } +IfcMassDensityMeasure::IfcMassDensityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcMassDensityMeasure::IfcMassDensityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMassDensityMeasure); e->setArgument(0, v); data_ = e; } +IfcMassDensityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMassFlowRateMeasure -IfcUtil::ArgumentType IfcMassFlowRateMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMassFlowRateMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMassFlowRateMeasure::is(Type::Enum v) const { return v == IfcMassFlowRateMeasure::Class(); } -Type::Enum IfcMassFlowRateMeasure::type() const { return Type::IfcMassFlowRateMeasure; } Type::Enum IfcMassFlowRateMeasure::Class() { return Type::IfcMassFlowRateMeasure; } -IfcMassFlowRateMeasure::IfcMassFlowRateMeasure(IfcAbstractEntity* e) { entity = e; } -IfcMassFlowRateMeasure::IfcMassFlowRateMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMassFlowRateMeasure); e->setArgument(0, v); entity = e; } -IfcMassFlowRateMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMassFlowRateMeasure::declaration() const { return *IfcMassFlowRateMeasure_type; } +IfcMassFlowRateMeasure::IfcMassFlowRateMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcMassFlowRateMeasure::IfcMassFlowRateMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMassFlowRateMeasure); e->setArgument(0, v); data_ = e; } +IfcMassFlowRateMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMassMeasure -IfcUtil::ArgumentType IfcMassMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMassMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMassMeasure::is(Type::Enum v) const { return v == IfcMassMeasure::Class(); } -Type::Enum IfcMassMeasure::type() const { return Type::IfcMassMeasure; } Type::Enum IfcMassMeasure::Class() { return Type::IfcMassMeasure; } -IfcMassMeasure::IfcMassMeasure(IfcAbstractEntity* e) { entity = e; } -IfcMassMeasure::IfcMassMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMassMeasure); e->setArgument(0, v); entity = e; } -IfcMassMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMassMeasure::declaration() const { return *IfcMassMeasure_type; } +IfcMassMeasure::IfcMassMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcMassMeasure::IfcMassMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMassMeasure); e->setArgument(0, v); data_ = e; } +IfcMassMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMassPerLengthMeasure -IfcUtil::ArgumentType IfcMassPerLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMassPerLengthMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMassPerLengthMeasure::is(Type::Enum v) const { return v == IfcMassPerLengthMeasure::Class(); } -Type::Enum IfcMassPerLengthMeasure::type() const { return Type::IfcMassPerLengthMeasure; } Type::Enum IfcMassPerLengthMeasure::Class() { return Type::IfcMassPerLengthMeasure; } -IfcMassPerLengthMeasure::IfcMassPerLengthMeasure(IfcAbstractEntity* e) { entity = e; } -IfcMassPerLengthMeasure::IfcMassPerLengthMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMassPerLengthMeasure); e->setArgument(0, v); entity = e; } -IfcMassPerLengthMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMassPerLengthMeasure::declaration() const { return *IfcMassPerLengthMeasure_type; } +IfcMassPerLengthMeasure::IfcMassPerLengthMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcMassPerLengthMeasure::IfcMassPerLengthMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMassPerLengthMeasure); e->setArgument(0, v); data_ = e; } +IfcMassPerLengthMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMinuteInHour -IfcUtil::ArgumentType IfcMinuteInHour::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMinuteInHour::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMinuteInHour::is(Type::Enum v) const { return v == IfcMinuteInHour::Class(); } -Type::Enum IfcMinuteInHour::type() const { return Type::IfcMinuteInHour; } Type::Enum IfcMinuteInHour::Class() { return Type::IfcMinuteInHour; } -IfcMinuteInHour::IfcMinuteInHour(IfcAbstractEntity* e) { entity = e; } -IfcMinuteInHour::IfcMinuteInHour(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMinuteInHour); e->setArgument(0, v); entity = e; } -IfcMinuteInHour::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMinuteInHour::declaration() const { return *IfcMinuteInHour_type; } +IfcMinuteInHour::IfcMinuteInHour(IfcAbstractEntity* e) { data_ = e; } +IfcMinuteInHour::IfcMinuteInHour(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMinuteInHour); e->setArgument(0, v); data_ = e; } +IfcMinuteInHour::operator int() const { return *data_->getArgument(0); } // Function implementations for IfcModulusOfElasticityMeasure -IfcUtil::ArgumentType IfcModulusOfElasticityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcModulusOfElasticityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcModulusOfElasticityMeasure::is(Type::Enum v) const { return v == IfcModulusOfElasticityMeasure::Class(); } -Type::Enum IfcModulusOfElasticityMeasure::type() const { return Type::IfcModulusOfElasticityMeasure; } Type::Enum IfcModulusOfElasticityMeasure::Class() { return Type::IfcModulusOfElasticityMeasure; } -IfcModulusOfElasticityMeasure::IfcModulusOfElasticityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcModulusOfElasticityMeasure::IfcModulusOfElasticityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcModulusOfElasticityMeasure); e->setArgument(0, v); entity = e; } -IfcModulusOfElasticityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcModulusOfElasticityMeasure::declaration() const { return *IfcModulusOfElasticityMeasure_type; } +IfcModulusOfElasticityMeasure::IfcModulusOfElasticityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcModulusOfElasticityMeasure::IfcModulusOfElasticityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcModulusOfElasticityMeasure); e->setArgument(0, v); data_ = e; } +IfcModulusOfElasticityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure -IfcUtil::ArgumentType IfcModulusOfLinearSubgradeReactionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcModulusOfLinearSubgradeReactionMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcModulusOfLinearSubgradeReactionMeasure::is(Type::Enum v) const { return v == IfcModulusOfLinearSubgradeReactionMeasure::Class(); } -Type::Enum IfcModulusOfLinearSubgradeReactionMeasure::type() const { return Type::IfcModulusOfLinearSubgradeReactionMeasure; } Type::Enum IfcModulusOfLinearSubgradeReactionMeasure::Class() { return Type::IfcModulusOfLinearSubgradeReactionMeasure; } -IfcModulusOfLinearSubgradeReactionMeasure::IfcModulusOfLinearSubgradeReactionMeasure(IfcAbstractEntity* e) { entity = e; } -IfcModulusOfLinearSubgradeReactionMeasure::IfcModulusOfLinearSubgradeReactionMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcModulusOfLinearSubgradeReactionMeasure); e->setArgument(0, v); entity = e; } -IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcModulusOfLinearSubgradeReactionMeasure::declaration() const { return *IfcModulusOfLinearSubgradeReactionMeasure_type; } +IfcModulusOfLinearSubgradeReactionMeasure::IfcModulusOfLinearSubgradeReactionMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcModulusOfLinearSubgradeReactionMeasure::IfcModulusOfLinearSubgradeReactionMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcModulusOfLinearSubgradeReactionMeasure); e->setArgument(0, v); data_ = e; } +IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure -IfcUtil::ArgumentType IfcModulusOfRotationalSubgradeReactionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcModulusOfRotationalSubgradeReactionMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcModulusOfRotationalSubgradeReactionMeasure::is(Type::Enum v) const { return v == IfcModulusOfRotationalSubgradeReactionMeasure::Class(); } -Type::Enum IfcModulusOfRotationalSubgradeReactionMeasure::type() const { return Type::IfcModulusOfRotationalSubgradeReactionMeasure; } Type::Enum IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return Type::IfcModulusOfRotationalSubgradeReactionMeasure; } -IfcModulusOfRotationalSubgradeReactionMeasure::IfcModulusOfRotationalSubgradeReactionMeasure(IfcAbstractEntity* e) { entity = e; } -IfcModulusOfRotationalSubgradeReactionMeasure::IfcModulusOfRotationalSubgradeReactionMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcModulusOfRotationalSubgradeReactionMeasure); e->setArgument(0, v); entity = e; } -IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcModulusOfRotationalSubgradeReactionMeasure::declaration() const { return *IfcModulusOfRotationalSubgradeReactionMeasure_type; } +IfcModulusOfRotationalSubgradeReactionMeasure::IfcModulusOfRotationalSubgradeReactionMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcModulusOfRotationalSubgradeReactionMeasure::IfcModulusOfRotationalSubgradeReactionMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcModulusOfRotationalSubgradeReactionMeasure); e->setArgument(0, v); data_ = e; } +IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcModulusOfSubgradeReactionMeasure -IfcUtil::ArgumentType IfcModulusOfSubgradeReactionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcModulusOfSubgradeReactionMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcModulusOfSubgradeReactionMeasure::is(Type::Enum v) const { return v == IfcModulusOfSubgradeReactionMeasure::Class(); } -Type::Enum IfcModulusOfSubgradeReactionMeasure::type() const { return Type::IfcModulusOfSubgradeReactionMeasure; } Type::Enum IfcModulusOfSubgradeReactionMeasure::Class() { return Type::IfcModulusOfSubgradeReactionMeasure; } -IfcModulusOfSubgradeReactionMeasure::IfcModulusOfSubgradeReactionMeasure(IfcAbstractEntity* e) { entity = e; } -IfcModulusOfSubgradeReactionMeasure::IfcModulusOfSubgradeReactionMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcModulusOfSubgradeReactionMeasure); e->setArgument(0, v); entity = e; } -IfcModulusOfSubgradeReactionMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcModulusOfSubgradeReactionMeasure::declaration() const { return *IfcModulusOfSubgradeReactionMeasure_type; } +IfcModulusOfSubgradeReactionMeasure::IfcModulusOfSubgradeReactionMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcModulusOfSubgradeReactionMeasure::IfcModulusOfSubgradeReactionMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcModulusOfSubgradeReactionMeasure); e->setArgument(0, v); data_ = e; } +IfcModulusOfSubgradeReactionMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMoistureDiffusivityMeasure -IfcUtil::ArgumentType IfcMoistureDiffusivityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMoistureDiffusivityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMoistureDiffusivityMeasure::is(Type::Enum v) const { return v == IfcMoistureDiffusivityMeasure::Class(); } -Type::Enum IfcMoistureDiffusivityMeasure::type() const { return Type::IfcMoistureDiffusivityMeasure; } Type::Enum IfcMoistureDiffusivityMeasure::Class() { return Type::IfcMoistureDiffusivityMeasure; } -IfcMoistureDiffusivityMeasure::IfcMoistureDiffusivityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcMoistureDiffusivityMeasure::IfcMoistureDiffusivityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMoistureDiffusivityMeasure); e->setArgument(0, v); entity = e; } -IfcMoistureDiffusivityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMoistureDiffusivityMeasure::declaration() const { return *IfcMoistureDiffusivityMeasure_type; } +IfcMoistureDiffusivityMeasure::IfcMoistureDiffusivityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcMoistureDiffusivityMeasure::IfcMoistureDiffusivityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMoistureDiffusivityMeasure); e->setArgument(0, v); data_ = e; } +IfcMoistureDiffusivityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMolecularWeightMeasure -IfcUtil::ArgumentType IfcMolecularWeightMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMolecularWeightMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMolecularWeightMeasure::is(Type::Enum v) const { return v == IfcMolecularWeightMeasure::Class(); } -Type::Enum IfcMolecularWeightMeasure::type() const { return Type::IfcMolecularWeightMeasure; } Type::Enum IfcMolecularWeightMeasure::Class() { return Type::IfcMolecularWeightMeasure; } -IfcMolecularWeightMeasure::IfcMolecularWeightMeasure(IfcAbstractEntity* e) { entity = e; } -IfcMolecularWeightMeasure::IfcMolecularWeightMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMolecularWeightMeasure); e->setArgument(0, v); entity = e; } -IfcMolecularWeightMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMolecularWeightMeasure::declaration() const { return *IfcMolecularWeightMeasure_type; } +IfcMolecularWeightMeasure::IfcMolecularWeightMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcMolecularWeightMeasure::IfcMolecularWeightMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMolecularWeightMeasure); e->setArgument(0, v); data_ = e; } +IfcMolecularWeightMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMomentOfInertiaMeasure -IfcUtil::ArgumentType IfcMomentOfInertiaMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMomentOfInertiaMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMomentOfInertiaMeasure::is(Type::Enum v) const { return v == IfcMomentOfInertiaMeasure::Class(); } -Type::Enum IfcMomentOfInertiaMeasure::type() const { return Type::IfcMomentOfInertiaMeasure; } Type::Enum IfcMomentOfInertiaMeasure::Class() { return Type::IfcMomentOfInertiaMeasure; } -IfcMomentOfInertiaMeasure::IfcMomentOfInertiaMeasure(IfcAbstractEntity* e) { entity = e; } -IfcMomentOfInertiaMeasure::IfcMomentOfInertiaMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMomentOfInertiaMeasure); e->setArgument(0, v); entity = e; } -IfcMomentOfInertiaMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMomentOfInertiaMeasure::declaration() const { return *IfcMomentOfInertiaMeasure_type; } +IfcMomentOfInertiaMeasure::IfcMomentOfInertiaMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcMomentOfInertiaMeasure::IfcMomentOfInertiaMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMomentOfInertiaMeasure); e->setArgument(0, v); data_ = e; } +IfcMomentOfInertiaMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMonetaryMeasure -IfcUtil::ArgumentType IfcMonetaryMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMonetaryMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMonetaryMeasure::is(Type::Enum v) const { return v == IfcMonetaryMeasure::Class(); } -Type::Enum IfcMonetaryMeasure::type() const { return Type::IfcMonetaryMeasure; } Type::Enum IfcMonetaryMeasure::Class() { return Type::IfcMonetaryMeasure; } -IfcMonetaryMeasure::IfcMonetaryMeasure(IfcAbstractEntity* e) { entity = e; } -IfcMonetaryMeasure::IfcMonetaryMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMonetaryMeasure); e->setArgument(0, v); entity = e; } -IfcMonetaryMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMonetaryMeasure::declaration() const { return *IfcMonetaryMeasure_type; } +IfcMonetaryMeasure::IfcMonetaryMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcMonetaryMeasure::IfcMonetaryMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMonetaryMeasure); e->setArgument(0, v); data_ = e; } +IfcMonetaryMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcMonthInYearNumber -IfcUtil::ArgumentType IfcMonthInYearNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcMonthInYearNumber::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcMonthInYearNumber::is(Type::Enum v) const { return v == IfcMonthInYearNumber::Class(); } -Type::Enum IfcMonthInYearNumber::type() const { return Type::IfcMonthInYearNumber; } Type::Enum IfcMonthInYearNumber::Class() { return Type::IfcMonthInYearNumber; } -IfcMonthInYearNumber::IfcMonthInYearNumber(IfcAbstractEntity* e) { entity = e; } -IfcMonthInYearNumber::IfcMonthInYearNumber(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMonthInYearNumber); e->setArgument(0, v); entity = e; } -IfcMonthInYearNumber::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcMonthInYearNumber::declaration() const { return *IfcMonthInYearNumber_type; } +IfcMonthInYearNumber::IfcMonthInYearNumber(IfcAbstractEntity* e) { data_ = e; } +IfcMonthInYearNumber::IfcMonthInYearNumber(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcMonthInYearNumber); e->setArgument(0, v); data_ = e; } +IfcMonthInYearNumber::operator int() const { return *data_->getArgument(0); } // Function implementations for IfcNormalisedRatioMeasure -IfcUtil::ArgumentType IfcNormalisedRatioMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcNormalisedRatioMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcNormalisedRatioMeasure::is(Type::Enum v) const { return v == Type::IfcNormalisedRatioMeasure || IfcRatioMeasure::is(v); } -Type::Enum IfcNormalisedRatioMeasure::type() const { return Type::IfcNormalisedRatioMeasure; } Type::Enum IfcNormalisedRatioMeasure::Class() { return Type::IfcNormalisedRatioMeasure; } -IfcNormalisedRatioMeasure::IfcNormalisedRatioMeasure(IfcAbstractEntity* e) : IfcRatioMeasure((IfcAbstractEntity*)0) { entity = e; } -IfcNormalisedRatioMeasure::IfcNormalisedRatioMeasure(double v) : IfcRatioMeasure((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcNormalisedRatioMeasure); e->setArgument(0, v); entity = e; } -IfcNormalisedRatioMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcNormalisedRatioMeasure::declaration() const { return *IfcNormalisedRatioMeasure_type; } +IfcNormalisedRatioMeasure::IfcNormalisedRatioMeasure(IfcAbstractEntity* e) : IfcRatioMeasure((IfcAbstractEntity*)0) { data_ = e; } +IfcNormalisedRatioMeasure::IfcNormalisedRatioMeasure(double v) : IfcRatioMeasure((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcNormalisedRatioMeasure); e->setArgument(0, v); data_ = e; } +IfcNormalisedRatioMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcNumericMeasure -IfcUtil::ArgumentType IfcNumericMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcNumericMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcNumericMeasure::is(Type::Enum v) const { return v == IfcNumericMeasure::Class(); } -Type::Enum IfcNumericMeasure::type() const { return Type::IfcNumericMeasure; } Type::Enum IfcNumericMeasure::Class() { return Type::IfcNumericMeasure; } -IfcNumericMeasure::IfcNumericMeasure(IfcAbstractEntity* e) { entity = e; } -IfcNumericMeasure::IfcNumericMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcNumericMeasure); e->setArgument(0, v); entity = e; } -IfcNumericMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcNumericMeasure::declaration() const { return *IfcNumericMeasure_type; } +IfcNumericMeasure::IfcNumericMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcNumericMeasure::IfcNumericMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcNumericMeasure); e->setArgument(0, v); data_ = e; } +IfcNumericMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcPHMeasure -IfcUtil::ArgumentType IfcPHMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcPHMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcPHMeasure::is(Type::Enum v) const { return v == IfcPHMeasure::Class(); } -Type::Enum IfcPHMeasure::type() const { return Type::IfcPHMeasure; } Type::Enum IfcPHMeasure::Class() { return Type::IfcPHMeasure; } -IfcPHMeasure::IfcPHMeasure(IfcAbstractEntity* e) { entity = e; } -IfcPHMeasure::IfcPHMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPHMeasure); e->setArgument(0, v); entity = e; } -IfcPHMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcPHMeasure::declaration() const { return *IfcPHMeasure_type; } +IfcPHMeasure::IfcPHMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcPHMeasure::IfcPHMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPHMeasure); e->setArgument(0, v); data_ = e; } +IfcPHMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcParameterValue -IfcUtil::ArgumentType IfcParameterValue::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcParameterValue::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcParameterValue::is(Type::Enum v) const { return v == IfcParameterValue::Class(); } -Type::Enum IfcParameterValue::type() const { return Type::IfcParameterValue; } Type::Enum IfcParameterValue::Class() { return Type::IfcParameterValue; } -IfcParameterValue::IfcParameterValue(IfcAbstractEntity* e) { entity = e; } -IfcParameterValue::IfcParameterValue(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcParameterValue); e->setArgument(0, v); entity = e; } -IfcParameterValue::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcParameterValue::declaration() const { return *IfcParameterValue_type; } +IfcParameterValue::IfcParameterValue(IfcAbstractEntity* e) { data_ = e; } +IfcParameterValue::IfcParameterValue(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcParameterValue); e->setArgument(0, v); data_ = e; } +IfcParameterValue::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcPlanarForceMeasure -IfcUtil::ArgumentType IfcPlanarForceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcPlanarForceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcPlanarForceMeasure::is(Type::Enum v) const { return v == IfcPlanarForceMeasure::Class(); } -Type::Enum IfcPlanarForceMeasure::type() const { return Type::IfcPlanarForceMeasure; } Type::Enum IfcPlanarForceMeasure::Class() { return Type::IfcPlanarForceMeasure; } -IfcPlanarForceMeasure::IfcPlanarForceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcPlanarForceMeasure::IfcPlanarForceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPlanarForceMeasure); e->setArgument(0, v); entity = e; } -IfcPlanarForceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcPlanarForceMeasure::declaration() const { return *IfcPlanarForceMeasure_type; } +IfcPlanarForceMeasure::IfcPlanarForceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcPlanarForceMeasure::IfcPlanarForceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPlanarForceMeasure); e->setArgument(0, v); data_ = e; } +IfcPlanarForceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcPlaneAngleMeasure -IfcUtil::ArgumentType IfcPlaneAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcPlaneAngleMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcPlaneAngleMeasure::is(Type::Enum v) const { return v == IfcPlaneAngleMeasure::Class(); } -Type::Enum IfcPlaneAngleMeasure::type() const { return Type::IfcPlaneAngleMeasure; } Type::Enum IfcPlaneAngleMeasure::Class() { return Type::IfcPlaneAngleMeasure; } -IfcPlaneAngleMeasure::IfcPlaneAngleMeasure(IfcAbstractEntity* e) { entity = e; } -IfcPlaneAngleMeasure::IfcPlaneAngleMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPlaneAngleMeasure); e->setArgument(0, v); entity = e; } -IfcPlaneAngleMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcPlaneAngleMeasure::declaration() const { return *IfcPlaneAngleMeasure_type; } +IfcPlaneAngleMeasure::IfcPlaneAngleMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcPlaneAngleMeasure::IfcPlaneAngleMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPlaneAngleMeasure); e->setArgument(0, v); data_ = e; } +IfcPlaneAngleMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcPositiveLengthMeasure -IfcUtil::ArgumentType IfcPositiveLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcPositiveLengthMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcPositiveLengthMeasure::is(Type::Enum v) const { return v == Type::IfcPositiveLengthMeasure || IfcLengthMeasure::is(v); } -Type::Enum IfcPositiveLengthMeasure::type() const { return Type::IfcPositiveLengthMeasure; } Type::Enum IfcPositiveLengthMeasure::Class() { return Type::IfcPositiveLengthMeasure; } -IfcPositiveLengthMeasure::IfcPositiveLengthMeasure(IfcAbstractEntity* e) : IfcLengthMeasure((IfcAbstractEntity*)0) { entity = e; } -IfcPositiveLengthMeasure::IfcPositiveLengthMeasure(double v) : IfcLengthMeasure((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPositiveLengthMeasure); e->setArgument(0, v); entity = e; } -IfcPositiveLengthMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcPositiveLengthMeasure::declaration() const { return *IfcPositiveLengthMeasure_type; } +IfcPositiveLengthMeasure::IfcPositiveLengthMeasure(IfcAbstractEntity* e) : IfcLengthMeasure((IfcAbstractEntity*)0) { data_ = e; } +IfcPositiveLengthMeasure::IfcPositiveLengthMeasure(double v) : IfcLengthMeasure((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPositiveLengthMeasure); e->setArgument(0, v); data_ = e; } +IfcPositiveLengthMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcPositivePlaneAngleMeasure -IfcUtil::ArgumentType IfcPositivePlaneAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcPositivePlaneAngleMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcPositivePlaneAngleMeasure::is(Type::Enum v) const { return v == Type::IfcPositivePlaneAngleMeasure || IfcPlaneAngleMeasure::is(v); } -Type::Enum IfcPositivePlaneAngleMeasure::type() const { return Type::IfcPositivePlaneAngleMeasure; } Type::Enum IfcPositivePlaneAngleMeasure::Class() { return Type::IfcPositivePlaneAngleMeasure; } -IfcPositivePlaneAngleMeasure::IfcPositivePlaneAngleMeasure(IfcAbstractEntity* e) : IfcPlaneAngleMeasure((IfcAbstractEntity*)0) { entity = e; } -IfcPositivePlaneAngleMeasure::IfcPositivePlaneAngleMeasure(double v) : IfcPlaneAngleMeasure((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPositivePlaneAngleMeasure); e->setArgument(0, v); entity = e; } -IfcPositivePlaneAngleMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcPositivePlaneAngleMeasure::declaration() const { return *IfcPositivePlaneAngleMeasure_type; } +IfcPositivePlaneAngleMeasure::IfcPositivePlaneAngleMeasure(IfcAbstractEntity* e) : IfcPlaneAngleMeasure((IfcAbstractEntity*)0) { data_ = e; } +IfcPositivePlaneAngleMeasure::IfcPositivePlaneAngleMeasure(double v) : IfcPlaneAngleMeasure((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPositivePlaneAngleMeasure); e->setArgument(0, v); data_ = e; } +IfcPositivePlaneAngleMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcPositiveRatioMeasure -IfcUtil::ArgumentType IfcPositiveRatioMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcPositiveRatioMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcPositiveRatioMeasure::is(Type::Enum v) const { return v == Type::IfcPositiveRatioMeasure || IfcRatioMeasure::is(v); } -Type::Enum IfcPositiveRatioMeasure::type() const { return Type::IfcPositiveRatioMeasure; } Type::Enum IfcPositiveRatioMeasure::Class() { return Type::IfcPositiveRatioMeasure; } -IfcPositiveRatioMeasure::IfcPositiveRatioMeasure(IfcAbstractEntity* e) : IfcRatioMeasure((IfcAbstractEntity*)0) { entity = e; } -IfcPositiveRatioMeasure::IfcPositiveRatioMeasure(double v) : IfcRatioMeasure((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPositiveRatioMeasure); e->setArgument(0, v); entity = e; } -IfcPositiveRatioMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcPositiveRatioMeasure::declaration() const { return *IfcPositiveRatioMeasure_type; } +IfcPositiveRatioMeasure::IfcPositiveRatioMeasure(IfcAbstractEntity* e) : IfcRatioMeasure((IfcAbstractEntity*)0) { data_ = e; } +IfcPositiveRatioMeasure::IfcPositiveRatioMeasure(double v) : IfcRatioMeasure((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPositiveRatioMeasure); e->setArgument(0, v); data_ = e; } +IfcPositiveRatioMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcPowerMeasure -IfcUtil::ArgumentType IfcPowerMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcPowerMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcPowerMeasure::is(Type::Enum v) const { return v == IfcPowerMeasure::Class(); } -Type::Enum IfcPowerMeasure::type() const { return Type::IfcPowerMeasure; } Type::Enum IfcPowerMeasure::Class() { return Type::IfcPowerMeasure; } -IfcPowerMeasure::IfcPowerMeasure(IfcAbstractEntity* e) { entity = e; } -IfcPowerMeasure::IfcPowerMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPowerMeasure); e->setArgument(0, v); entity = e; } -IfcPowerMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcPowerMeasure::declaration() const { return *IfcPowerMeasure_type; } +IfcPowerMeasure::IfcPowerMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcPowerMeasure::IfcPowerMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPowerMeasure); e->setArgument(0, v); data_ = e; } +IfcPowerMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcPresentableText -IfcUtil::ArgumentType IfcPresentableText::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcPresentableText::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcPresentableText::is(Type::Enum v) const { return v == IfcPresentableText::Class(); } -Type::Enum IfcPresentableText::type() const { return Type::IfcPresentableText; } Type::Enum IfcPresentableText::Class() { return Type::IfcPresentableText; } -IfcPresentableText::IfcPresentableText(IfcAbstractEntity* e) { entity = e; } -IfcPresentableText::IfcPresentableText(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPresentableText); e->setArgument(0, v); entity = e; } -IfcPresentableText::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcPresentableText::declaration() const { return *IfcPresentableText_type; } +IfcPresentableText::IfcPresentableText(IfcAbstractEntity* e) { data_ = e; } +IfcPresentableText::IfcPresentableText(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPresentableText); e->setArgument(0, v); data_ = e; } +IfcPresentableText::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcPressureMeasure -IfcUtil::ArgumentType IfcPressureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcPressureMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcPressureMeasure::is(Type::Enum v) const { return v == IfcPressureMeasure::Class(); } -Type::Enum IfcPressureMeasure::type() const { return Type::IfcPressureMeasure; } Type::Enum IfcPressureMeasure::Class() { return Type::IfcPressureMeasure; } -IfcPressureMeasure::IfcPressureMeasure(IfcAbstractEntity* e) { entity = e; } -IfcPressureMeasure::IfcPressureMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPressureMeasure); e->setArgument(0, v); entity = e; } -IfcPressureMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcPressureMeasure::declaration() const { return *IfcPressureMeasure_type; } +IfcPressureMeasure::IfcPressureMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcPressureMeasure::IfcPressureMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPressureMeasure); e->setArgument(0, v); data_ = e; } +IfcPressureMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcRadioActivityMeasure -IfcUtil::ArgumentType IfcRadioActivityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcRadioActivityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcRadioActivityMeasure::is(Type::Enum v) const { return v == IfcRadioActivityMeasure::Class(); } -Type::Enum IfcRadioActivityMeasure::type() const { return Type::IfcRadioActivityMeasure; } Type::Enum IfcRadioActivityMeasure::Class() { return Type::IfcRadioActivityMeasure; } -IfcRadioActivityMeasure::IfcRadioActivityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcRadioActivityMeasure::IfcRadioActivityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcRadioActivityMeasure); e->setArgument(0, v); entity = e; } -IfcRadioActivityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcRadioActivityMeasure::declaration() const { return *IfcRadioActivityMeasure_type; } +IfcRadioActivityMeasure::IfcRadioActivityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcRadioActivityMeasure::IfcRadioActivityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcRadioActivityMeasure); e->setArgument(0, v); data_ = e; } +IfcRadioActivityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcRatioMeasure -IfcUtil::ArgumentType IfcRatioMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcRatioMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcRatioMeasure::is(Type::Enum v) const { return v == IfcRatioMeasure::Class(); } -Type::Enum IfcRatioMeasure::type() const { return Type::IfcRatioMeasure; } Type::Enum IfcRatioMeasure::Class() { return Type::IfcRatioMeasure; } -IfcRatioMeasure::IfcRatioMeasure(IfcAbstractEntity* e) { entity = e; } -IfcRatioMeasure::IfcRatioMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcRatioMeasure); e->setArgument(0, v); entity = e; } -IfcRatioMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcRatioMeasure::declaration() const { return *IfcRatioMeasure_type; } +IfcRatioMeasure::IfcRatioMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcRatioMeasure::IfcRatioMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcRatioMeasure); e->setArgument(0, v); data_ = e; } +IfcRatioMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcReal -IfcUtil::ArgumentType IfcReal::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcReal::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcReal::is(Type::Enum v) const { return v == IfcReal::Class(); } -Type::Enum IfcReal::type() const { return Type::IfcReal; } Type::Enum IfcReal::Class() { return Type::IfcReal; } -IfcReal::IfcReal(IfcAbstractEntity* e) { entity = e; } -IfcReal::IfcReal(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcReal); e->setArgument(0, v); entity = e; } -IfcReal::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcReal::declaration() const { return *IfcReal_type; } +IfcReal::IfcReal(IfcAbstractEntity* e) { data_ = e; } +IfcReal::IfcReal(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcReal); e->setArgument(0, v); data_ = e; } +IfcReal::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcRotationalFrequencyMeasure -IfcUtil::ArgumentType IfcRotationalFrequencyMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcRotationalFrequencyMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcRotationalFrequencyMeasure::is(Type::Enum v) const { return v == IfcRotationalFrequencyMeasure::Class(); } -Type::Enum IfcRotationalFrequencyMeasure::type() const { return Type::IfcRotationalFrequencyMeasure; } Type::Enum IfcRotationalFrequencyMeasure::Class() { return Type::IfcRotationalFrequencyMeasure; } -IfcRotationalFrequencyMeasure::IfcRotationalFrequencyMeasure(IfcAbstractEntity* e) { entity = e; } -IfcRotationalFrequencyMeasure::IfcRotationalFrequencyMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcRotationalFrequencyMeasure); e->setArgument(0, v); entity = e; } -IfcRotationalFrequencyMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcRotationalFrequencyMeasure::declaration() const { return *IfcRotationalFrequencyMeasure_type; } +IfcRotationalFrequencyMeasure::IfcRotationalFrequencyMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcRotationalFrequencyMeasure::IfcRotationalFrequencyMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcRotationalFrequencyMeasure); e->setArgument(0, v); data_ = e; } +IfcRotationalFrequencyMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcRotationalMassMeasure -IfcUtil::ArgumentType IfcRotationalMassMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcRotationalMassMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcRotationalMassMeasure::is(Type::Enum v) const { return v == IfcRotationalMassMeasure::Class(); } -Type::Enum IfcRotationalMassMeasure::type() const { return Type::IfcRotationalMassMeasure; } Type::Enum IfcRotationalMassMeasure::Class() { return Type::IfcRotationalMassMeasure; } -IfcRotationalMassMeasure::IfcRotationalMassMeasure(IfcAbstractEntity* e) { entity = e; } -IfcRotationalMassMeasure::IfcRotationalMassMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcRotationalMassMeasure); e->setArgument(0, v); entity = e; } -IfcRotationalMassMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcRotationalMassMeasure::declaration() const { return *IfcRotationalMassMeasure_type; } +IfcRotationalMassMeasure::IfcRotationalMassMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcRotationalMassMeasure::IfcRotationalMassMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcRotationalMassMeasure); e->setArgument(0, v); data_ = e; } +IfcRotationalMassMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcRotationalStiffnessMeasure -IfcUtil::ArgumentType IfcRotationalStiffnessMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcRotationalStiffnessMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcRotationalStiffnessMeasure::is(Type::Enum v) const { return v == IfcRotationalStiffnessMeasure::Class(); } -Type::Enum IfcRotationalStiffnessMeasure::type() const { return Type::IfcRotationalStiffnessMeasure; } Type::Enum IfcRotationalStiffnessMeasure::Class() { return Type::IfcRotationalStiffnessMeasure; } -IfcRotationalStiffnessMeasure::IfcRotationalStiffnessMeasure(IfcAbstractEntity* e) { entity = e; } -IfcRotationalStiffnessMeasure::IfcRotationalStiffnessMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcRotationalStiffnessMeasure); e->setArgument(0, v); entity = e; } -IfcRotationalStiffnessMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcRotationalStiffnessMeasure::declaration() const { return *IfcRotationalStiffnessMeasure_type; } +IfcRotationalStiffnessMeasure::IfcRotationalStiffnessMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcRotationalStiffnessMeasure::IfcRotationalStiffnessMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcRotationalStiffnessMeasure); e->setArgument(0, v); data_ = e; } +IfcRotationalStiffnessMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcSecondInMinute -IfcUtil::ArgumentType IfcSecondInMinute::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcSecondInMinute::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcSecondInMinute::is(Type::Enum v) const { return v == IfcSecondInMinute::Class(); } -Type::Enum IfcSecondInMinute::type() const { return Type::IfcSecondInMinute; } Type::Enum IfcSecondInMinute::Class() { return Type::IfcSecondInMinute; } -IfcSecondInMinute::IfcSecondInMinute(IfcAbstractEntity* e) { entity = e; } -IfcSecondInMinute::IfcSecondInMinute(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSecondInMinute); e->setArgument(0, v); entity = e; } -IfcSecondInMinute::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcSecondInMinute::declaration() const { return *IfcSecondInMinute_type; } +IfcSecondInMinute::IfcSecondInMinute(IfcAbstractEntity* e) { data_ = e; } +IfcSecondInMinute::IfcSecondInMinute(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSecondInMinute); e->setArgument(0, v); data_ = e; } +IfcSecondInMinute::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcSectionModulusMeasure -IfcUtil::ArgumentType IfcSectionModulusMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcSectionModulusMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcSectionModulusMeasure::is(Type::Enum v) const { return v == IfcSectionModulusMeasure::Class(); } -Type::Enum IfcSectionModulusMeasure::type() const { return Type::IfcSectionModulusMeasure; } Type::Enum IfcSectionModulusMeasure::Class() { return Type::IfcSectionModulusMeasure; } -IfcSectionModulusMeasure::IfcSectionModulusMeasure(IfcAbstractEntity* e) { entity = e; } -IfcSectionModulusMeasure::IfcSectionModulusMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSectionModulusMeasure); e->setArgument(0, v); entity = e; } -IfcSectionModulusMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcSectionModulusMeasure::declaration() const { return *IfcSectionModulusMeasure_type; } +IfcSectionModulusMeasure::IfcSectionModulusMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcSectionModulusMeasure::IfcSectionModulusMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSectionModulusMeasure); e->setArgument(0, v); data_ = e; } +IfcSectionModulusMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcSectionalAreaIntegralMeasure -IfcUtil::ArgumentType IfcSectionalAreaIntegralMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcSectionalAreaIntegralMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcSectionalAreaIntegralMeasure::is(Type::Enum v) const { return v == IfcSectionalAreaIntegralMeasure::Class(); } -Type::Enum IfcSectionalAreaIntegralMeasure::type() const { return Type::IfcSectionalAreaIntegralMeasure; } Type::Enum IfcSectionalAreaIntegralMeasure::Class() { return Type::IfcSectionalAreaIntegralMeasure; } -IfcSectionalAreaIntegralMeasure::IfcSectionalAreaIntegralMeasure(IfcAbstractEntity* e) { entity = e; } -IfcSectionalAreaIntegralMeasure::IfcSectionalAreaIntegralMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSectionalAreaIntegralMeasure); e->setArgument(0, v); entity = e; } -IfcSectionalAreaIntegralMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcSectionalAreaIntegralMeasure::declaration() const { return *IfcSectionalAreaIntegralMeasure_type; } +IfcSectionalAreaIntegralMeasure::IfcSectionalAreaIntegralMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcSectionalAreaIntegralMeasure::IfcSectionalAreaIntegralMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSectionalAreaIntegralMeasure); e->setArgument(0, v); data_ = e; } +IfcSectionalAreaIntegralMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcShearModulusMeasure -IfcUtil::ArgumentType IfcShearModulusMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcShearModulusMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcShearModulusMeasure::is(Type::Enum v) const { return v == IfcShearModulusMeasure::Class(); } -Type::Enum IfcShearModulusMeasure::type() const { return Type::IfcShearModulusMeasure; } Type::Enum IfcShearModulusMeasure::Class() { return Type::IfcShearModulusMeasure; } -IfcShearModulusMeasure::IfcShearModulusMeasure(IfcAbstractEntity* e) { entity = e; } -IfcShearModulusMeasure::IfcShearModulusMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcShearModulusMeasure); e->setArgument(0, v); entity = e; } -IfcShearModulusMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcShearModulusMeasure::declaration() const { return *IfcShearModulusMeasure_type; } +IfcShearModulusMeasure::IfcShearModulusMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcShearModulusMeasure::IfcShearModulusMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcShearModulusMeasure); e->setArgument(0, v); data_ = e; } +IfcShearModulusMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcSolidAngleMeasure -IfcUtil::ArgumentType IfcSolidAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcSolidAngleMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcSolidAngleMeasure::is(Type::Enum v) const { return v == IfcSolidAngleMeasure::Class(); } -Type::Enum IfcSolidAngleMeasure::type() const { return Type::IfcSolidAngleMeasure; } Type::Enum IfcSolidAngleMeasure::Class() { return Type::IfcSolidAngleMeasure; } -IfcSolidAngleMeasure::IfcSolidAngleMeasure(IfcAbstractEntity* e) { entity = e; } -IfcSolidAngleMeasure::IfcSolidAngleMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSolidAngleMeasure); e->setArgument(0, v); entity = e; } -IfcSolidAngleMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcSolidAngleMeasure::declaration() const { return *IfcSolidAngleMeasure_type; } +IfcSolidAngleMeasure::IfcSolidAngleMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcSolidAngleMeasure::IfcSolidAngleMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSolidAngleMeasure); e->setArgument(0, v); data_ = e; } +IfcSolidAngleMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcSoundPowerMeasure -IfcUtil::ArgumentType IfcSoundPowerMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcSoundPowerMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcSoundPowerMeasure::is(Type::Enum v) const { return v == IfcSoundPowerMeasure::Class(); } -Type::Enum IfcSoundPowerMeasure::type() const { return Type::IfcSoundPowerMeasure; } Type::Enum IfcSoundPowerMeasure::Class() { return Type::IfcSoundPowerMeasure; } -IfcSoundPowerMeasure::IfcSoundPowerMeasure(IfcAbstractEntity* e) { entity = e; } -IfcSoundPowerMeasure::IfcSoundPowerMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSoundPowerMeasure); e->setArgument(0, v); entity = e; } -IfcSoundPowerMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcSoundPowerMeasure::declaration() const { return *IfcSoundPowerMeasure_type; } +IfcSoundPowerMeasure::IfcSoundPowerMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcSoundPowerMeasure::IfcSoundPowerMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSoundPowerMeasure); e->setArgument(0, v); data_ = e; } +IfcSoundPowerMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcSoundPressureMeasure -IfcUtil::ArgumentType IfcSoundPressureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcSoundPressureMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcSoundPressureMeasure::is(Type::Enum v) const { return v == IfcSoundPressureMeasure::Class(); } -Type::Enum IfcSoundPressureMeasure::type() const { return Type::IfcSoundPressureMeasure; } Type::Enum IfcSoundPressureMeasure::Class() { return Type::IfcSoundPressureMeasure; } -IfcSoundPressureMeasure::IfcSoundPressureMeasure(IfcAbstractEntity* e) { entity = e; } -IfcSoundPressureMeasure::IfcSoundPressureMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSoundPressureMeasure); e->setArgument(0, v); entity = e; } -IfcSoundPressureMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcSoundPressureMeasure::declaration() const { return *IfcSoundPressureMeasure_type; } +IfcSoundPressureMeasure::IfcSoundPressureMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcSoundPressureMeasure::IfcSoundPressureMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSoundPressureMeasure); e->setArgument(0, v); data_ = e; } +IfcSoundPressureMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcSpecificHeatCapacityMeasure -IfcUtil::ArgumentType IfcSpecificHeatCapacityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcSpecificHeatCapacityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcSpecificHeatCapacityMeasure::is(Type::Enum v) const { return v == IfcSpecificHeatCapacityMeasure::Class(); } -Type::Enum IfcSpecificHeatCapacityMeasure::type() const { return Type::IfcSpecificHeatCapacityMeasure; } Type::Enum IfcSpecificHeatCapacityMeasure::Class() { return Type::IfcSpecificHeatCapacityMeasure; } -IfcSpecificHeatCapacityMeasure::IfcSpecificHeatCapacityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcSpecificHeatCapacityMeasure::IfcSpecificHeatCapacityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSpecificHeatCapacityMeasure); e->setArgument(0, v); entity = e; } -IfcSpecificHeatCapacityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcSpecificHeatCapacityMeasure::declaration() const { return *IfcSpecificHeatCapacityMeasure_type; } +IfcSpecificHeatCapacityMeasure::IfcSpecificHeatCapacityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcSpecificHeatCapacityMeasure::IfcSpecificHeatCapacityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSpecificHeatCapacityMeasure); e->setArgument(0, v); data_ = e; } +IfcSpecificHeatCapacityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcSpecularExponent -IfcUtil::ArgumentType IfcSpecularExponent::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcSpecularExponent::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcSpecularExponent::is(Type::Enum v) const { return v == IfcSpecularExponent::Class(); } -Type::Enum IfcSpecularExponent::type() const { return Type::IfcSpecularExponent; } Type::Enum IfcSpecularExponent::Class() { return Type::IfcSpecularExponent; } -IfcSpecularExponent::IfcSpecularExponent(IfcAbstractEntity* e) { entity = e; } -IfcSpecularExponent::IfcSpecularExponent(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSpecularExponent); e->setArgument(0, v); entity = e; } -IfcSpecularExponent::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcSpecularExponent::declaration() const { return *IfcSpecularExponent_type; } +IfcSpecularExponent::IfcSpecularExponent(IfcAbstractEntity* e) { data_ = e; } +IfcSpecularExponent::IfcSpecularExponent(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSpecularExponent); e->setArgument(0, v); data_ = e; } +IfcSpecularExponent::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcSpecularRoughness -IfcUtil::ArgumentType IfcSpecularRoughness::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcSpecularRoughness::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcSpecularRoughness::is(Type::Enum v) const { return v == IfcSpecularRoughness::Class(); } -Type::Enum IfcSpecularRoughness::type() const { return Type::IfcSpecularRoughness; } Type::Enum IfcSpecularRoughness::Class() { return Type::IfcSpecularRoughness; } -IfcSpecularRoughness::IfcSpecularRoughness(IfcAbstractEntity* e) { entity = e; } -IfcSpecularRoughness::IfcSpecularRoughness(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSpecularRoughness); e->setArgument(0, v); entity = e; } -IfcSpecularRoughness::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcSpecularRoughness::declaration() const { return *IfcSpecularRoughness_type; } +IfcSpecularRoughness::IfcSpecularRoughness(IfcAbstractEntity* e) { data_ = e; } +IfcSpecularRoughness::IfcSpecularRoughness(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSpecularRoughness); e->setArgument(0, v); data_ = e; } +IfcSpecularRoughness::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcTemperatureGradientMeasure -IfcUtil::ArgumentType IfcTemperatureGradientMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcTemperatureGradientMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcTemperatureGradientMeasure::is(Type::Enum v) const { return v == IfcTemperatureGradientMeasure::Class(); } -Type::Enum IfcTemperatureGradientMeasure::type() const { return Type::IfcTemperatureGradientMeasure; } Type::Enum IfcTemperatureGradientMeasure::Class() { return Type::IfcTemperatureGradientMeasure; } -IfcTemperatureGradientMeasure::IfcTemperatureGradientMeasure(IfcAbstractEntity* e) { entity = e; } -IfcTemperatureGradientMeasure::IfcTemperatureGradientMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTemperatureGradientMeasure); e->setArgument(0, v); entity = e; } -IfcTemperatureGradientMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcTemperatureGradientMeasure::declaration() const { return *IfcTemperatureGradientMeasure_type; } +IfcTemperatureGradientMeasure::IfcTemperatureGradientMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcTemperatureGradientMeasure::IfcTemperatureGradientMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTemperatureGradientMeasure); e->setArgument(0, v); data_ = e; } +IfcTemperatureGradientMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcText -IfcUtil::ArgumentType IfcText::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcText::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcText::is(Type::Enum v) const { return v == IfcText::Class(); } -Type::Enum IfcText::type() const { return Type::IfcText; } Type::Enum IfcText::Class() { return Type::IfcText; } -IfcText::IfcText(IfcAbstractEntity* e) { entity = e; } -IfcText::IfcText(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcText); e->setArgument(0, v); entity = e; } -IfcText::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcText::declaration() const { return *IfcText_type; } +IfcText::IfcText(IfcAbstractEntity* e) { data_ = e; } +IfcText::IfcText(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcText); e->setArgument(0, v); data_ = e; } +IfcText::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcTextAlignment -IfcUtil::ArgumentType IfcTextAlignment::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcTextAlignment::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcTextAlignment::is(Type::Enum v) const { return v == IfcTextAlignment::Class(); } -Type::Enum IfcTextAlignment::type() const { return Type::IfcTextAlignment; } Type::Enum IfcTextAlignment::Class() { return Type::IfcTextAlignment; } -IfcTextAlignment::IfcTextAlignment(IfcAbstractEntity* e) { entity = e; } -IfcTextAlignment::IfcTextAlignment(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTextAlignment); e->setArgument(0, v); entity = e; } -IfcTextAlignment::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcTextAlignment::declaration() const { return *IfcTextAlignment_type; } +IfcTextAlignment::IfcTextAlignment(IfcAbstractEntity* e) { data_ = e; } +IfcTextAlignment::IfcTextAlignment(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTextAlignment); e->setArgument(0, v); data_ = e; } +IfcTextAlignment::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcTextDecoration -IfcUtil::ArgumentType IfcTextDecoration::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcTextDecoration::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcTextDecoration::is(Type::Enum v) const { return v == IfcTextDecoration::Class(); } -Type::Enum IfcTextDecoration::type() const { return Type::IfcTextDecoration; } Type::Enum IfcTextDecoration::Class() { return Type::IfcTextDecoration; } -IfcTextDecoration::IfcTextDecoration(IfcAbstractEntity* e) { entity = e; } -IfcTextDecoration::IfcTextDecoration(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTextDecoration); e->setArgument(0, v); entity = e; } -IfcTextDecoration::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcTextDecoration::declaration() const { return *IfcTextDecoration_type; } +IfcTextDecoration::IfcTextDecoration(IfcAbstractEntity* e) { data_ = e; } +IfcTextDecoration::IfcTextDecoration(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTextDecoration); e->setArgument(0, v); data_ = e; } +IfcTextDecoration::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcTextFontName -IfcUtil::ArgumentType IfcTextFontName::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcTextFontName::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcTextFontName::is(Type::Enum v) const { return v == IfcTextFontName::Class(); } -Type::Enum IfcTextFontName::type() const { return Type::IfcTextFontName; } Type::Enum IfcTextFontName::Class() { return Type::IfcTextFontName; } -IfcTextFontName::IfcTextFontName(IfcAbstractEntity* e) { entity = e; } -IfcTextFontName::IfcTextFontName(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTextFontName); e->setArgument(0, v); entity = e; } -IfcTextFontName::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcTextFontName::declaration() const { return *IfcTextFontName_type; } +IfcTextFontName::IfcTextFontName(IfcAbstractEntity* e) { data_ = e; } +IfcTextFontName::IfcTextFontName(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTextFontName); e->setArgument(0, v); data_ = e; } +IfcTextFontName::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcTextTransformation -IfcUtil::ArgumentType IfcTextTransformation::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcTextTransformation::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcTextTransformation::is(Type::Enum v) const { return v == IfcTextTransformation::Class(); } -Type::Enum IfcTextTransformation::type() const { return Type::IfcTextTransformation; } Type::Enum IfcTextTransformation::Class() { return Type::IfcTextTransformation; } -IfcTextTransformation::IfcTextTransformation(IfcAbstractEntity* e) { entity = e; } -IfcTextTransformation::IfcTextTransformation(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTextTransformation); e->setArgument(0, v); entity = e; } -IfcTextTransformation::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcTextTransformation::declaration() const { return *IfcTextTransformation_type; } +IfcTextTransformation::IfcTextTransformation(IfcAbstractEntity* e) { data_ = e; } +IfcTextTransformation::IfcTextTransformation(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTextTransformation); e->setArgument(0, v); data_ = e; } +IfcTextTransformation::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcThermalAdmittanceMeasure -IfcUtil::ArgumentType IfcThermalAdmittanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcThermalAdmittanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcThermalAdmittanceMeasure::is(Type::Enum v) const { return v == IfcThermalAdmittanceMeasure::Class(); } -Type::Enum IfcThermalAdmittanceMeasure::type() const { return Type::IfcThermalAdmittanceMeasure; } Type::Enum IfcThermalAdmittanceMeasure::Class() { return Type::IfcThermalAdmittanceMeasure; } -IfcThermalAdmittanceMeasure::IfcThermalAdmittanceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcThermalAdmittanceMeasure::IfcThermalAdmittanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermalAdmittanceMeasure); e->setArgument(0, v); entity = e; } -IfcThermalAdmittanceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcThermalAdmittanceMeasure::declaration() const { return *IfcThermalAdmittanceMeasure_type; } +IfcThermalAdmittanceMeasure::IfcThermalAdmittanceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcThermalAdmittanceMeasure::IfcThermalAdmittanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermalAdmittanceMeasure); e->setArgument(0, v); data_ = e; } +IfcThermalAdmittanceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcThermalConductivityMeasure -IfcUtil::ArgumentType IfcThermalConductivityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcThermalConductivityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcThermalConductivityMeasure::is(Type::Enum v) const { return v == IfcThermalConductivityMeasure::Class(); } -Type::Enum IfcThermalConductivityMeasure::type() const { return Type::IfcThermalConductivityMeasure; } Type::Enum IfcThermalConductivityMeasure::Class() { return Type::IfcThermalConductivityMeasure; } -IfcThermalConductivityMeasure::IfcThermalConductivityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcThermalConductivityMeasure::IfcThermalConductivityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermalConductivityMeasure); e->setArgument(0, v); entity = e; } -IfcThermalConductivityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcThermalConductivityMeasure::declaration() const { return *IfcThermalConductivityMeasure_type; } +IfcThermalConductivityMeasure::IfcThermalConductivityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcThermalConductivityMeasure::IfcThermalConductivityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermalConductivityMeasure); e->setArgument(0, v); data_ = e; } +IfcThermalConductivityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcThermalExpansionCoefficientMeasure -IfcUtil::ArgumentType IfcThermalExpansionCoefficientMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcThermalExpansionCoefficientMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcThermalExpansionCoefficientMeasure::is(Type::Enum v) const { return v == IfcThermalExpansionCoefficientMeasure::Class(); } -Type::Enum IfcThermalExpansionCoefficientMeasure::type() const { return Type::IfcThermalExpansionCoefficientMeasure; } Type::Enum IfcThermalExpansionCoefficientMeasure::Class() { return Type::IfcThermalExpansionCoefficientMeasure; } -IfcThermalExpansionCoefficientMeasure::IfcThermalExpansionCoefficientMeasure(IfcAbstractEntity* e) { entity = e; } -IfcThermalExpansionCoefficientMeasure::IfcThermalExpansionCoefficientMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermalExpansionCoefficientMeasure); e->setArgument(0, v); entity = e; } -IfcThermalExpansionCoefficientMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcThermalExpansionCoefficientMeasure::declaration() const { return *IfcThermalExpansionCoefficientMeasure_type; } +IfcThermalExpansionCoefficientMeasure::IfcThermalExpansionCoefficientMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcThermalExpansionCoefficientMeasure::IfcThermalExpansionCoefficientMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermalExpansionCoefficientMeasure); e->setArgument(0, v); data_ = e; } +IfcThermalExpansionCoefficientMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcThermalResistanceMeasure -IfcUtil::ArgumentType IfcThermalResistanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcThermalResistanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcThermalResistanceMeasure::is(Type::Enum v) const { return v == IfcThermalResistanceMeasure::Class(); } -Type::Enum IfcThermalResistanceMeasure::type() const { return Type::IfcThermalResistanceMeasure; } Type::Enum IfcThermalResistanceMeasure::Class() { return Type::IfcThermalResistanceMeasure; } -IfcThermalResistanceMeasure::IfcThermalResistanceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcThermalResistanceMeasure::IfcThermalResistanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermalResistanceMeasure); e->setArgument(0, v); entity = e; } -IfcThermalResistanceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcThermalResistanceMeasure::declaration() const { return *IfcThermalResistanceMeasure_type; } +IfcThermalResistanceMeasure::IfcThermalResistanceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcThermalResistanceMeasure::IfcThermalResistanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermalResistanceMeasure); e->setArgument(0, v); data_ = e; } +IfcThermalResistanceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcThermalTransmittanceMeasure -IfcUtil::ArgumentType IfcThermalTransmittanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcThermalTransmittanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcThermalTransmittanceMeasure::is(Type::Enum v) const { return v == IfcThermalTransmittanceMeasure::Class(); } -Type::Enum IfcThermalTransmittanceMeasure::type() const { return Type::IfcThermalTransmittanceMeasure; } Type::Enum IfcThermalTransmittanceMeasure::Class() { return Type::IfcThermalTransmittanceMeasure; } -IfcThermalTransmittanceMeasure::IfcThermalTransmittanceMeasure(IfcAbstractEntity* e) { entity = e; } -IfcThermalTransmittanceMeasure::IfcThermalTransmittanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermalTransmittanceMeasure); e->setArgument(0, v); entity = e; } -IfcThermalTransmittanceMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcThermalTransmittanceMeasure::declaration() const { return *IfcThermalTransmittanceMeasure_type; } +IfcThermalTransmittanceMeasure::IfcThermalTransmittanceMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcThermalTransmittanceMeasure::IfcThermalTransmittanceMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermalTransmittanceMeasure); e->setArgument(0, v); data_ = e; } +IfcThermalTransmittanceMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcThermodynamicTemperatureMeasure -IfcUtil::ArgumentType IfcThermodynamicTemperatureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcThermodynamicTemperatureMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcThermodynamicTemperatureMeasure::is(Type::Enum v) const { return v == IfcThermodynamicTemperatureMeasure::Class(); } -Type::Enum IfcThermodynamicTemperatureMeasure::type() const { return Type::IfcThermodynamicTemperatureMeasure; } Type::Enum IfcThermodynamicTemperatureMeasure::Class() { return Type::IfcThermodynamicTemperatureMeasure; } -IfcThermodynamicTemperatureMeasure::IfcThermodynamicTemperatureMeasure(IfcAbstractEntity* e) { entity = e; } -IfcThermodynamicTemperatureMeasure::IfcThermodynamicTemperatureMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermodynamicTemperatureMeasure); e->setArgument(0, v); entity = e; } -IfcThermodynamicTemperatureMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcThermodynamicTemperatureMeasure::declaration() const { return *IfcThermodynamicTemperatureMeasure_type; } +IfcThermodynamicTemperatureMeasure::IfcThermodynamicTemperatureMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcThermodynamicTemperatureMeasure::IfcThermodynamicTemperatureMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcThermodynamicTemperatureMeasure); e->setArgument(0, v); data_ = e; } +IfcThermodynamicTemperatureMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcTimeMeasure -IfcUtil::ArgumentType IfcTimeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcTimeMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcTimeMeasure::is(Type::Enum v) const { return v == IfcTimeMeasure::Class(); } -Type::Enum IfcTimeMeasure::type() const { return Type::IfcTimeMeasure; } Type::Enum IfcTimeMeasure::Class() { return Type::IfcTimeMeasure; } -IfcTimeMeasure::IfcTimeMeasure(IfcAbstractEntity* e) { entity = e; } -IfcTimeMeasure::IfcTimeMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTimeMeasure); e->setArgument(0, v); entity = e; } -IfcTimeMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcTimeMeasure::declaration() const { return *IfcTimeMeasure_type; } +IfcTimeMeasure::IfcTimeMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcTimeMeasure::IfcTimeMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTimeMeasure); e->setArgument(0, v); data_ = e; } +IfcTimeMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcTimeStamp -IfcUtil::ArgumentType IfcTimeStamp::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcTimeStamp::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcTimeStamp::is(Type::Enum v) const { return v == IfcTimeStamp::Class(); } -Type::Enum IfcTimeStamp::type() const { return Type::IfcTimeStamp; } Type::Enum IfcTimeStamp::Class() { return Type::IfcTimeStamp; } -IfcTimeStamp::IfcTimeStamp(IfcAbstractEntity* e) { entity = e; } -IfcTimeStamp::IfcTimeStamp(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTimeStamp); e->setArgument(0, v); entity = e; } -IfcTimeStamp::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcTimeStamp::declaration() const { return *IfcTimeStamp_type; } +IfcTimeStamp::IfcTimeStamp(IfcAbstractEntity* e) { data_ = e; } +IfcTimeStamp::IfcTimeStamp(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTimeStamp); e->setArgument(0, v); data_ = e; } +IfcTimeStamp::operator int() const { return *data_->getArgument(0); } // Function implementations for IfcTorqueMeasure -IfcUtil::ArgumentType IfcTorqueMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcTorqueMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcTorqueMeasure::is(Type::Enum v) const { return v == IfcTorqueMeasure::Class(); } -Type::Enum IfcTorqueMeasure::type() const { return Type::IfcTorqueMeasure; } Type::Enum IfcTorqueMeasure::Class() { return Type::IfcTorqueMeasure; } -IfcTorqueMeasure::IfcTorqueMeasure(IfcAbstractEntity* e) { entity = e; } -IfcTorqueMeasure::IfcTorqueMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTorqueMeasure); e->setArgument(0, v); entity = e; } -IfcTorqueMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcTorqueMeasure::declaration() const { return *IfcTorqueMeasure_type; } +IfcTorqueMeasure::IfcTorqueMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcTorqueMeasure::IfcTorqueMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTorqueMeasure); e->setArgument(0, v); data_ = e; } +IfcTorqueMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcVaporPermeabilityMeasure -IfcUtil::ArgumentType IfcVaporPermeabilityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcVaporPermeabilityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcVaporPermeabilityMeasure::is(Type::Enum v) const { return v == IfcVaporPermeabilityMeasure::Class(); } -Type::Enum IfcVaporPermeabilityMeasure::type() const { return Type::IfcVaporPermeabilityMeasure; } Type::Enum IfcVaporPermeabilityMeasure::Class() { return Type::IfcVaporPermeabilityMeasure; } -IfcVaporPermeabilityMeasure::IfcVaporPermeabilityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcVaporPermeabilityMeasure::IfcVaporPermeabilityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcVaporPermeabilityMeasure); e->setArgument(0, v); entity = e; } -IfcVaporPermeabilityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcVaporPermeabilityMeasure::declaration() const { return *IfcVaporPermeabilityMeasure_type; } +IfcVaporPermeabilityMeasure::IfcVaporPermeabilityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcVaporPermeabilityMeasure::IfcVaporPermeabilityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcVaporPermeabilityMeasure); e->setArgument(0, v); data_ = e; } +IfcVaporPermeabilityMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcVolumeMeasure -IfcUtil::ArgumentType IfcVolumeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcVolumeMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcVolumeMeasure::is(Type::Enum v) const { return v == IfcVolumeMeasure::Class(); } -Type::Enum IfcVolumeMeasure::type() const { return Type::IfcVolumeMeasure; } Type::Enum IfcVolumeMeasure::Class() { return Type::IfcVolumeMeasure; } -IfcVolumeMeasure::IfcVolumeMeasure(IfcAbstractEntity* e) { entity = e; } -IfcVolumeMeasure::IfcVolumeMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcVolumeMeasure); e->setArgument(0, v); entity = e; } -IfcVolumeMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcVolumeMeasure::declaration() const { return *IfcVolumeMeasure_type; } +IfcVolumeMeasure::IfcVolumeMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcVolumeMeasure::IfcVolumeMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcVolumeMeasure); e->setArgument(0, v); data_ = e; } +IfcVolumeMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcVolumetricFlowRateMeasure -IfcUtil::ArgumentType IfcVolumetricFlowRateMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcVolumetricFlowRateMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcVolumetricFlowRateMeasure::is(Type::Enum v) const { return v == IfcVolumetricFlowRateMeasure::Class(); } -Type::Enum IfcVolumetricFlowRateMeasure::type() const { return Type::IfcVolumetricFlowRateMeasure; } Type::Enum IfcVolumetricFlowRateMeasure::Class() { return Type::IfcVolumetricFlowRateMeasure; } -IfcVolumetricFlowRateMeasure::IfcVolumetricFlowRateMeasure(IfcAbstractEntity* e) { entity = e; } -IfcVolumetricFlowRateMeasure::IfcVolumetricFlowRateMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcVolumetricFlowRateMeasure); e->setArgument(0, v); entity = e; } -IfcVolumetricFlowRateMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcVolumetricFlowRateMeasure::declaration() const { return *IfcVolumetricFlowRateMeasure_type; } +IfcVolumetricFlowRateMeasure::IfcVolumetricFlowRateMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcVolumetricFlowRateMeasure::IfcVolumetricFlowRateMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcVolumetricFlowRateMeasure); e->setArgument(0, v); data_ = e; } +IfcVolumetricFlowRateMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcWarpingConstantMeasure -IfcUtil::ArgumentType IfcWarpingConstantMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcWarpingConstantMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcWarpingConstantMeasure::is(Type::Enum v) const { return v == IfcWarpingConstantMeasure::Class(); } -Type::Enum IfcWarpingConstantMeasure::type() const { return Type::IfcWarpingConstantMeasure; } Type::Enum IfcWarpingConstantMeasure::Class() { return Type::IfcWarpingConstantMeasure; } -IfcWarpingConstantMeasure::IfcWarpingConstantMeasure(IfcAbstractEntity* e) { entity = e; } -IfcWarpingConstantMeasure::IfcWarpingConstantMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcWarpingConstantMeasure); e->setArgument(0, v); entity = e; } -IfcWarpingConstantMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcWarpingConstantMeasure::declaration() const { return *IfcWarpingConstantMeasure_type; } +IfcWarpingConstantMeasure::IfcWarpingConstantMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcWarpingConstantMeasure::IfcWarpingConstantMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcWarpingConstantMeasure); e->setArgument(0, v); data_ = e; } +IfcWarpingConstantMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcWarpingMomentMeasure -IfcUtil::ArgumentType IfcWarpingMomentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcWarpingMomentMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcWarpingMomentMeasure::is(Type::Enum v) const { return v == IfcWarpingMomentMeasure::Class(); } -Type::Enum IfcWarpingMomentMeasure::type() const { return Type::IfcWarpingMomentMeasure; } Type::Enum IfcWarpingMomentMeasure::Class() { return Type::IfcWarpingMomentMeasure; } -IfcWarpingMomentMeasure::IfcWarpingMomentMeasure(IfcAbstractEntity* e) { entity = e; } -IfcWarpingMomentMeasure::IfcWarpingMomentMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcWarpingMomentMeasure); e->setArgument(0, v); entity = e; } -IfcWarpingMomentMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcWarpingMomentMeasure::declaration() const { return *IfcWarpingMomentMeasure_type; } +IfcWarpingMomentMeasure::IfcWarpingMomentMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcWarpingMomentMeasure::IfcWarpingMomentMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcWarpingMomentMeasure); e->setArgument(0, v); data_ = e; } +IfcWarpingMomentMeasure::operator double() const { return *data_->getArgument(0); } // Function implementations for IfcYearNumber -IfcUtil::ArgumentType IfcYearNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcYearNumber::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcYearNumber::is(Type::Enum v) const { return v == IfcYearNumber::Class(); } -Type::Enum IfcYearNumber::type() const { return Type::IfcYearNumber; } Type::Enum IfcYearNumber::Class() { return Type::IfcYearNumber; } -IfcYearNumber::IfcYearNumber(IfcAbstractEntity* e) { entity = e; } -IfcYearNumber::IfcYearNumber(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcYearNumber); e->setArgument(0, v); entity = e; } -IfcYearNumber::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcYearNumber::declaration() const { return *IfcYearNumber_type; } +IfcYearNumber::IfcYearNumber(IfcAbstractEntity* e) { data_ = e; } +IfcYearNumber::IfcYearNumber(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcYearNumber); e->setArgument(0, v); data_ = e; } +IfcYearNumber::operator int() const { return *data_->getArgument(0); } // Function implementations for Ifc2DCompositeCurve -bool Ifc2DCompositeCurve::is(Type::Enum v) const { return v == Type::Ifc2DCompositeCurve || IfcCompositeCurve::is(v); } -Type::Enum Ifc2DCompositeCurve::type() const { return Type::Ifc2DCompositeCurve; } + + +const IfcParse::entity& Ifc2DCompositeCurve::declaration() const { return *Ifc2DCompositeCurve_type; } Type::Enum Ifc2DCompositeCurve::Class() { return Type::Ifc2DCompositeCurve; } -Ifc2DCompositeCurve::Ifc2DCompositeCurve(IfcAbstractEntity* e) : IfcCompositeCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::Ifc2DCompositeCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -Ifc2DCompositeCurve::Ifc2DCompositeCurve(IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect) : IfcCompositeCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Segments)->generalize()); e->setArgument(1,(v2_SelfIntersect)); entity = e; EntityBuffer::Add(this); } +Ifc2DCompositeCurve::Ifc2DCompositeCurve(IfcAbstractEntity* e) : IfcCompositeCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::Ifc2DCompositeCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +Ifc2DCompositeCurve::Ifc2DCompositeCurve(IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect) : IfcCompositeCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Segments)->generalize()); e->setArgument(1,(v2_SelfIntersect)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcActionRequest -std::string IfcActionRequest::RequestID() const { return *entity->getArgument(5); } -void IfcActionRequest::setRequestID(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcActionRequest::is(Type::Enum v) const { return v == Type::IfcActionRequest || IfcControl::is(v); } -Type::Enum IfcActionRequest::type() const { return Type::IfcActionRequest; } +std::string IfcActionRequest::RequestID() const { return *data_->getArgument(5); } +void IfcActionRequest::setRequestID(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcActionRequest::declaration() const { return *IfcActionRequest_type; } Type::Enum IfcActionRequest::Class() { return Type::IfcActionRequest; } -IfcActionRequest::IfcActionRequest(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcActionRequest)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcActionRequest::IfcActionRequest(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_RequestID) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_RequestID)); entity = e; EntityBuffer::Add(this); } +IfcActionRequest::IfcActionRequest(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcActionRequest)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcActionRequest::IfcActionRequest(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_RequestID) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_RequestID)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcActor -IfcActorSelect* IfcActor::TheActor() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcActor::setTheActor(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcRelAssignsToActor::list::ptr IfcActor::IsActingUpon() const { return entity->getInverse(Type::IfcRelAssignsToActor, 6)->as(); } -bool IfcActor::is(Type::Enum v) const { return v == Type::IfcActor || IfcObject::is(v); } -Type::Enum IfcActor::type() const { return Type::IfcActor; } +IfcActorSelect* IfcActor::TheActor() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcActor::setTheActor(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + +IfcRelAssignsToActor::list::ptr IfcActor::IsActingUpon() const { return data_->getInverse(Type::IfcRelAssignsToActor, 6)->as(); } + +const IfcParse::entity& IfcActor::declaration() const { return *IfcActor_type; } Type::Enum IfcActor::Class() { return Type::IfcActor; } -IfcActor::IfcActor(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcActor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcActor::IfcActor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcActorSelect* v6_TheActor) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_TheActor)); entity = e; EntityBuffer::Add(this); } +IfcActor::IfcActor(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcActor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcActor::IfcActor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcActorSelect* v6_TheActor) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_TheActor)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcActorRole -IfcRoleEnum::IfcRoleEnum IfcActorRole::Role() const { return IfcRoleEnum::FromString(*entity->getArgument(0)); } -void IfcActorRole::setRole(IfcRoleEnum::IfcRoleEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v,IfcRoleEnum::ToString(v)); } -bool IfcActorRole::hasUserDefinedRole() const { return !entity->getArgument(1)->isNull(); } -std::string IfcActorRole::UserDefinedRole() const { return *entity->getArgument(1); } -void IfcActorRole::setUserDefinedRole(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcActorRole::hasDescription() const { return !entity->getArgument(2)->isNull(); } -std::string IfcActorRole::Description() const { return *entity->getArgument(2); } -void IfcActorRole::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcActorRole::is(Type::Enum v) const { return v == Type::IfcActorRole; } -Type::Enum IfcActorRole::type() const { return Type::IfcActorRole; } +IfcRoleEnum::IfcRoleEnum IfcActorRole::Role() const { return IfcRoleEnum::FromString(*data_->getArgument(0)); } +void IfcActorRole::setRole(IfcRoleEnum::IfcRoleEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v,IfcRoleEnum::ToString(v)); } +bool IfcActorRole::hasUserDefinedRole() const { return !data_->getArgument(1)->isNull(); } +std::string IfcActorRole::UserDefinedRole() const { return *data_->getArgument(1); } +void IfcActorRole::setUserDefinedRole(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcActorRole::hasDescription() const { return !data_->getArgument(2)->isNull(); } +std::string IfcActorRole::Description() const { return *data_->getArgument(2); } +void IfcActorRole::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcActorRole::declaration() const { return *IfcActorRole_type; } Type::Enum IfcActorRole::Class() { return Type::IfcActorRole; } -IfcActorRole::IfcActorRole(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcActorRole)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcActorRole::IfcActorRole(IfcRoleEnum::IfcRoleEnum v1_Role, boost::optional< std::string > v2_UserDefinedRole, boost::optional< std::string > v3_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_Role,IfcRoleEnum::ToString(v1_Role)); if (v2_UserDefinedRole) { e->setArgument(1,(*v2_UserDefinedRole)); } else { e->setArgument(1); } if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcActorRole::IfcActorRole(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcActorRole)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcActorRole::IfcActorRole(IfcRoleEnum::IfcRoleEnum v1_Role, boost::optional< std::string > v2_UserDefinedRole, boost::optional< std::string > v3_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_Role,IfcRoleEnum::ToString(v1_Role)); if (v2_UserDefinedRole) { e->setArgument(1,(*v2_UserDefinedRole)); } else { e->setArgument(1); } if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcActuatorType -IfcActuatorTypeEnum::IfcActuatorTypeEnum IfcActuatorType::PredefinedType() const { return IfcActuatorTypeEnum::FromString(*entity->getArgument(9)); } -void IfcActuatorType::setPredefinedType(IfcActuatorTypeEnum::IfcActuatorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcActuatorTypeEnum::ToString(v)); } -bool IfcActuatorType::is(Type::Enum v) const { return v == Type::IfcActuatorType || IfcDistributionControlElementType::is(v); } -Type::Enum IfcActuatorType::type() const { return Type::IfcActuatorType; } +IfcActuatorTypeEnum::IfcActuatorTypeEnum IfcActuatorType::PredefinedType() const { return IfcActuatorTypeEnum::FromString(*data_->getArgument(9)); } +void IfcActuatorType::setPredefinedType(IfcActuatorTypeEnum::IfcActuatorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcActuatorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcActuatorType::declaration() const { return *IfcActuatorType_type; } Type::Enum IfcActuatorType::Class() { return Type::IfcActuatorType; } -IfcActuatorType::IfcActuatorType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcActuatorType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcActuatorType::IfcActuatorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcActuatorTypeEnum::IfcActuatorTypeEnum v10_PredefinedType) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcActuatorTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcActuatorType::IfcActuatorType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcActuatorType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcActuatorType::IfcActuatorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcActuatorTypeEnum::IfcActuatorTypeEnum v10_PredefinedType) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcActuatorTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAddress -bool IfcAddress::hasPurpose() const { return !entity->getArgument(0)->isNull(); } -IfcAddressTypeEnum::IfcAddressTypeEnum IfcAddress::Purpose() const { return IfcAddressTypeEnum::FromString(*entity->getArgument(0)); } -void IfcAddress::setPurpose(IfcAddressTypeEnum::IfcAddressTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v,IfcAddressTypeEnum::ToString(v)); } -bool IfcAddress::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcAddress::Description() const { return *entity->getArgument(1); } -void IfcAddress::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcAddress::hasUserDefinedPurpose() const { return !entity->getArgument(2)->isNull(); } -std::string IfcAddress::UserDefinedPurpose() const { return *entity->getArgument(2); } -void IfcAddress::setUserDefinedPurpose(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcPerson::list::ptr IfcAddress::OfPerson() const { return entity->getInverse(Type::IfcPerson, 7)->as(); } -IfcOrganization::list::ptr IfcAddress::OfOrganization() const { return entity->getInverse(Type::IfcOrganization, 4)->as(); } -bool IfcAddress::is(Type::Enum v) const { return v == Type::IfcAddress; } -Type::Enum IfcAddress::type() const { return Type::IfcAddress; } +bool IfcAddress::hasPurpose() const { return !data_->getArgument(0)->isNull(); } +IfcAddressTypeEnum::IfcAddressTypeEnum IfcAddress::Purpose() const { return IfcAddressTypeEnum::FromString(*data_->getArgument(0)); } +void IfcAddress::setPurpose(IfcAddressTypeEnum::IfcAddressTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v,IfcAddressTypeEnum::ToString(v)); } +bool IfcAddress::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcAddress::Description() const { return *data_->getArgument(1); } +void IfcAddress::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcAddress::hasUserDefinedPurpose() const { return !data_->getArgument(2)->isNull(); } +std::string IfcAddress::UserDefinedPurpose() const { return *data_->getArgument(2); } +void IfcAddress::setUserDefinedPurpose(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + +IfcPerson::list::ptr IfcAddress::OfPerson() const { return data_->getInverse(Type::IfcPerson, 7)->as(); } +IfcOrganization::list::ptr IfcAddress::OfOrganization() const { return data_->getInverse(Type::IfcOrganization, 4)->as(); } + +const IfcParse::entity& IfcAddress::declaration() const { return *IfcAddress_type; } Type::Enum IfcAddress::Class() { return Type::IfcAddress; } -IfcAddress::IfcAddress(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcAddress)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAddress::IfcAddress(boost::optional< IfcAddressTypeEnum::IfcAddressTypeEnum > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Purpose) { e->setArgument(0,*v1_Purpose,IfcAddressTypeEnum::ToString(*v1_Purpose)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } if (v3_UserDefinedPurpose) { e->setArgument(2,(*v3_UserDefinedPurpose)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcAddress::IfcAddress(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcAddress)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAddress::IfcAddress(boost::optional< IfcAddressTypeEnum::IfcAddressTypeEnum > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Purpose) { e->setArgument(0,*v1_Purpose,IfcAddressTypeEnum::ToString(*v1_Purpose)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } if (v3_UserDefinedPurpose) { e->setArgument(2,(*v3_UserDefinedPurpose)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAirTerminalBoxType -IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum IfcAirTerminalBoxType::PredefinedType() const { return IfcAirTerminalBoxTypeEnum::FromString(*entity->getArgument(9)); } -void IfcAirTerminalBoxType::setPredefinedType(IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcAirTerminalBoxTypeEnum::ToString(v)); } -bool IfcAirTerminalBoxType::is(Type::Enum v) const { return v == Type::IfcAirTerminalBoxType || IfcFlowControllerType::is(v); } -Type::Enum IfcAirTerminalBoxType::type() const { return Type::IfcAirTerminalBoxType; } +IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum IfcAirTerminalBoxType::PredefinedType() const { return IfcAirTerminalBoxTypeEnum::FromString(*data_->getArgument(9)); } +void IfcAirTerminalBoxType::setPredefinedType(IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcAirTerminalBoxTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcAirTerminalBoxType::declaration() const { return *IfcAirTerminalBoxType_type; } Type::Enum IfcAirTerminalBoxType::Class() { return Type::IfcAirTerminalBoxType; } -IfcAirTerminalBoxType::IfcAirTerminalBoxType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirTerminalBoxType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAirTerminalBoxType::IfcAirTerminalBoxType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcAirTerminalBoxTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcAirTerminalBoxType::IfcAirTerminalBoxType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirTerminalBoxType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAirTerminalBoxType::IfcAirTerminalBoxType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcAirTerminalBoxTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAirTerminalType -IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum IfcAirTerminalType::PredefinedType() const { return IfcAirTerminalTypeEnum::FromString(*entity->getArgument(9)); } -void IfcAirTerminalType::setPredefinedType(IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcAirTerminalTypeEnum::ToString(v)); } -bool IfcAirTerminalType::is(Type::Enum v) const { return v == Type::IfcAirTerminalType || IfcFlowTerminalType::is(v); } -Type::Enum IfcAirTerminalType::type() const { return Type::IfcAirTerminalType; } +IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum IfcAirTerminalType::PredefinedType() const { return IfcAirTerminalTypeEnum::FromString(*data_->getArgument(9)); } +void IfcAirTerminalType::setPredefinedType(IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcAirTerminalTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcAirTerminalType::declaration() const { return *IfcAirTerminalType_type; } Type::Enum IfcAirTerminalType::Class() { return Type::IfcAirTerminalType; } -IfcAirTerminalType::IfcAirTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirTerminalType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAirTerminalType::IfcAirTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcAirTerminalTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcAirTerminalType::IfcAirTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirTerminalType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAirTerminalType::IfcAirTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcAirTerminalTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAirToAirHeatRecoveryType -IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum IfcAirToAirHeatRecoveryType::PredefinedType() const { return IfcAirToAirHeatRecoveryTypeEnum::FromString(*entity->getArgument(9)); } -void IfcAirToAirHeatRecoveryType::setPredefinedType(IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcAirToAirHeatRecoveryTypeEnum::ToString(v)); } -bool IfcAirToAirHeatRecoveryType::is(Type::Enum v) const { return v == Type::IfcAirToAirHeatRecoveryType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcAirToAirHeatRecoveryType::type() const { return Type::IfcAirToAirHeatRecoveryType; } +IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum IfcAirToAirHeatRecoveryType::PredefinedType() const { return IfcAirToAirHeatRecoveryTypeEnum::FromString(*data_->getArgument(9)); } +void IfcAirToAirHeatRecoveryType::setPredefinedType(IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcAirToAirHeatRecoveryTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcAirToAirHeatRecoveryType::declaration() const { return *IfcAirToAirHeatRecoveryType_type; } Type::Enum IfcAirToAirHeatRecoveryType::Class() { return Type::IfcAirToAirHeatRecoveryType; } -IfcAirToAirHeatRecoveryType::IfcAirToAirHeatRecoveryType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirToAirHeatRecoveryType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAirToAirHeatRecoveryType::IfcAirToAirHeatRecoveryType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcAirToAirHeatRecoveryTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcAirToAirHeatRecoveryType::IfcAirToAirHeatRecoveryType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirToAirHeatRecoveryType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAirToAirHeatRecoveryType::IfcAirToAirHeatRecoveryType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcAirToAirHeatRecoveryTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAlarmType -IfcAlarmTypeEnum::IfcAlarmTypeEnum IfcAlarmType::PredefinedType() const { return IfcAlarmTypeEnum::FromString(*entity->getArgument(9)); } -void IfcAlarmType::setPredefinedType(IfcAlarmTypeEnum::IfcAlarmTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcAlarmTypeEnum::ToString(v)); } -bool IfcAlarmType::is(Type::Enum v) const { return v == Type::IfcAlarmType || IfcDistributionControlElementType::is(v); } -Type::Enum IfcAlarmType::type() const { return Type::IfcAlarmType; } +IfcAlarmTypeEnum::IfcAlarmTypeEnum IfcAlarmType::PredefinedType() const { return IfcAlarmTypeEnum::FromString(*data_->getArgument(9)); } +void IfcAlarmType::setPredefinedType(IfcAlarmTypeEnum::IfcAlarmTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcAlarmTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcAlarmType::declaration() const { return *IfcAlarmType_type; } Type::Enum IfcAlarmType::Class() { return Type::IfcAlarmType; } -IfcAlarmType::IfcAlarmType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAlarmType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAlarmType::IfcAlarmType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAlarmTypeEnum::IfcAlarmTypeEnum v10_PredefinedType) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcAlarmTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcAlarmType::IfcAlarmType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAlarmType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAlarmType::IfcAlarmType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAlarmTypeEnum::IfcAlarmTypeEnum v10_PredefinedType) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcAlarmTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAngularDimension -bool IfcAngularDimension::is(Type::Enum v) const { return v == Type::IfcAngularDimension || IfcDimensionCurveDirectedCallout::is(v); } -Type::Enum IfcAngularDimension::type() const { return Type::IfcAngularDimension; } + + +const IfcParse::entity& IfcAngularDimension::declaration() const { return *IfcAngularDimension_type; } Type::Enum IfcAngularDimension::Class() { return Type::IfcAngularDimension; } -IfcAngularDimension::IfcAngularDimension(IfcAbstractEntity* e) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAngularDimension)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAngularDimension::IfcAngularDimension(IfcEntityList::ptr v1_Contents) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); entity = e; EntityBuffer::Add(this); } +IfcAngularDimension::IfcAngularDimension(IfcAbstractEntity* e) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAngularDimension)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAngularDimension::IfcAngularDimension(IfcEntityList::ptr v1_Contents) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAnnotation -IfcRelContainedInSpatialStructure::list::ptr IfcAnnotation::ContainedInStructure() const { return entity->getInverse(Type::IfcRelContainedInSpatialStructure, 4)->as(); } -bool IfcAnnotation::is(Type::Enum v) const { return v == Type::IfcAnnotation || IfcProduct::is(v); } -Type::Enum IfcAnnotation::type() const { return Type::IfcAnnotation; } + +IfcRelContainedInSpatialStructure::list::ptr IfcAnnotation::ContainedInStructure() const { return data_->getInverse(Type::IfcRelContainedInSpatialStructure, 4)->as(); } + +const IfcParse::entity& IfcAnnotation::declaration() const { return *IfcAnnotation_type; } Type::Enum IfcAnnotation::Class() { return Type::IfcAnnotation; } -IfcAnnotation::IfcAnnotation(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAnnotation::IfcAnnotation(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); entity = e; EntityBuffer::Add(this); } +IfcAnnotation::IfcAnnotation(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAnnotation::IfcAnnotation(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAnnotationCurveOccurrence -bool IfcAnnotationCurveOccurrence::is(Type::Enum v) const { return v == Type::IfcAnnotationCurveOccurrence || IfcAnnotationOccurrence::is(v); } -Type::Enum IfcAnnotationCurveOccurrence::type() const { return Type::IfcAnnotationCurveOccurrence; } + + +const IfcParse::entity& IfcAnnotationCurveOccurrence::declaration() const { return *IfcAnnotationCurveOccurrence_type; } Type::Enum IfcAnnotationCurveOccurrence::Class() { return Type::IfcAnnotationCurveOccurrence; } -IfcAnnotationCurveOccurrence::IfcAnnotationCurveOccurrence(IfcAbstractEntity* e) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationCurveOccurrence)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAnnotationCurveOccurrence::IfcAnnotationCurveOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcAnnotationCurveOccurrence::IfcAnnotationCurveOccurrence(IfcAbstractEntity* e) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationCurveOccurrence)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAnnotationCurveOccurrence::IfcAnnotationCurveOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAnnotationFillArea -IfcCurve* IfcAnnotationFillArea::OuterBoundary() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcAnnotationFillArea::setOuterBoundary(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcAnnotationFillArea::hasInnerBoundaries() const { return !entity->getArgument(1)->isNull(); } -IfcTemplatedEntityList< IfcCurve >::ptr IfcAnnotationFillArea::InnerBoundaries() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcAnnotationFillArea::setInnerBoundaries(IfcTemplatedEntityList< IfcCurve >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcAnnotationFillArea::is(Type::Enum v) const { return v == Type::IfcAnnotationFillArea || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcAnnotationFillArea::type() const { return Type::IfcAnnotationFillArea; } +IfcCurve* IfcAnnotationFillArea::OuterBoundary() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcAnnotationFillArea::setOuterBoundary(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcAnnotationFillArea::hasInnerBoundaries() const { return !data_->getArgument(1)->isNull(); } +IfcTemplatedEntityList< IfcCurve >::ptr IfcAnnotationFillArea::InnerBoundaries() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcAnnotationFillArea::setInnerBoundaries(IfcTemplatedEntityList< IfcCurve >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } + + +const IfcParse::entity& IfcAnnotationFillArea::declaration() const { return *IfcAnnotationFillArea_type; } Type::Enum IfcAnnotationFillArea::Class() { return Type::IfcAnnotationFillArea; } -IfcAnnotationFillArea::IfcAnnotationFillArea(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationFillArea)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAnnotationFillArea::IfcAnnotationFillArea(IfcCurve* v1_OuterBoundary, boost::optional< IfcTemplatedEntityList< IfcCurve >::ptr > v2_InnerBoundaries) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_OuterBoundary)); if (v2_InnerBoundaries) { e->setArgument(1,(*v2_InnerBoundaries)->generalize()); } else { e->setArgument(1); } entity = e; EntityBuffer::Add(this); } +IfcAnnotationFillArea::IfcAnnotationFillArea(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationFillArea)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAnnotationFillArea::IfcAnnotationFillArea(IfcCurve* v1_OuterBoundary, boost::optional< IfcTemplatedEntityList< IfcCurve >::ptr > v2_InnerBoundaries) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_OuterBoundary)); if (v2_InnerBoundaries) { e->setArgument(1,(*v2_InnerBoundaries)->generalize()); } else { e->setArgument(1); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAnnotationFillAreaOccurrence -bool IfcAnnotationFillAreaOccurrence::hasFillStyleTarget() const { return !entity->getArgument(3)->isNull(); } -IfcPoint* IfcAnnotationFillAreaOccurrence::FillStyleTarget() const { return (IfcPoint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcAnnotationFillAreaOccurrence::setFillStyleTarget(IfcPoint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcAnnotationFillAreaOccurrence::hasGlobalOrLocal() const { return !entity->getArgument(4)->isNull(); } -IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum IfcAnnotationFillAreaOccurrence::GlobalOrLocal() const { return IfcGlobalOrLocalEnum::FromString(*entity->getArgument(4)); } -void IfcAnnotationFillAreaOccurrence::setGlobalOrLocal(IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcGlobalOrLocalEnum::ToString(v)); } -bool IfcAnnotationFillAreaOccurrence::is(Type::Enum v) const { return v == Type::IfcAnnotationFillAreaOccurrence || IfcAnnotationOccurrence::is(v); } -Type::Enum IfcAnnotationFillAreaOccurrence::type() const { return Type::IfcAnnotationFillAreaOccurrence; } +bool IfcAnnotationFillAreaOccurrence::hasFillStyleTarget() const { return !data_->getArgument(3)->isNull(); } +IfcPoint* IfcAnnotationFillAreaOccurrence::FillStyleTarget() const { return (IfcPoint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcAnnotationFillAreaOccurrence::setFillStyleTarget(IfcPoint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcAnnotationFillAreaOccurrence::hasGlobalOrLocal() const { return !data_->getArgument(4)->isNull(); } +IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum IfcAnnotationFillAreaOccurrence::GlobalOrLocal() const { return IfcGlobalOrLocalEnum::FromString(*data_->getArgument(4)); } +void IfcAnnotationFillAreaOccurrence::setGlobalOrLocal(IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcGlobalOrLocalEnum::ToString(v)); } + + +const IfcParse::entity& IfcAnnotationFillAreaOccurrence::declaration() const { return *IfcAnnotationFillAreaOccurrence_type; } Type::Enum IfcAnnotationFillAreaOccurrence::Class() { return Type::IfcAnnotationFillAreaOccurrence; } -IfcAnnotationFillAreaOccurrence::IfcAnnotationFillAreaOccurrence(IfcAbstractEntity* e) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationFillAreaOccurrence)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAnnotationFillAreaOccurrence::IfcAnnotationFillAreaOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, IfcPoint* v4_FillStyleTarget, boost::optional< IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum > v5_GlobalOrLocal) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } e->setArgument(3,(v4_FillStyleTarget)); if (v5_GlobalOrLocal) { e->setArgument(4,*v5_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(*v5_GlobalOrLocal)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcAnnotationFillAreaOccurrence::IfcAnnotationFillAreaOccurrence(IfcAbstractEntity* e) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationFillAreaOccurrence)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAnnotationFillAreaOccurrence::IfcAnnotationFillAreaOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, IfcPoint* v4_FillStyleTarget, boost::optional< IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum > v5_GlobalOrLocal) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } e->setArgument(3,(v4_FillStyleTarget)); if (v5_GlobalOrLocal) { e->setArgument(4,*v5_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(*v5_GlobalOrLocal)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAnnotationOccurrence -bool IfcAnnotationOccurrence::is(Type::Enum v) const { return v == Type::IfcAnnotationOccurrence || IfcStyledItem::is(v); } -Type::Enum IfcAnnotationOccurrence::type() const { return Type::IfcAnnotationOccurrence; } + + +const IfcParse::entity& IfcAnnotationOccurrence::declaration() const { return *IfcAnnotationOccurrence_type; } Type::Enum IfcAnnotationOccurrence::Class() { return Type::IfcAnnotationOccurrence; } -IfcAnnotationOccurrence::IfcAnnotationOccurrence(IfcAbstractEntity* e) : IfcStyledItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationOccurrence)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAnnotationOccurrence::IfcAnnotationOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcStyledItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcAnnotationOccurrence::IfcAnnotationOccurrence(IfcAbstractEntity* e) : IfcStyledItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationOccurrence)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAnnotationOccurrence::IfcAnnotationOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcStyledItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAnnotationSurface -IfcGeometricRepresentationItem* IfcAnnotationSurface::Item() const { return (IfcGeometricRepresentationItem*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcAnnotationSurface::setItem(IfcGeometricRepresentationItem* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcAnnotationSurface::hasTextureCoordinates() const { return !entity->getArgument(1)->isNull(); } -IfcTextureCoordinate* IfcAnnotationSurface::TextureCoordinates() const { return (IfcTextureCoordinate*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcAnnotationSurface::setTextureCoordinates(IfcTextureCoordinate* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcAnnotationSurface::is(Type::Enum v) const { return v == Type::IfcAnnotationSurface || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcAnnotationSurface::type() const { return Type::IfcAnnotationSurface; } +IfcGeometricRepresentationItem* IfcAnnotationSurface::Item() const { return (IfcGeometricRepresentationItem*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcAnnotationSurface::setItem(IfcGeometricRepresentationItem* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcAnnotationSurface::hasTextureCoordinates() const { return !data_->getArgument(1)->isNull(); } +IfcTextureCoordinate* IfcAnnotationSurface::TextureCoordinates() const { return (IfcTextureCoordinate*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcAnnotationSurface::setTextureCoordinates(IfcTextureCoordinate* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcAnnotationSurface::declaration() const { return *IfcAnnotationSurface_type; } Type::Enum IfcAnnotationSurface::Class() { return Type::IfcAnnotationSurface; } -IfcAnnotationSurface::IfcAnnotationSurface(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationSurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAnnotationSurface::IfcAnnotationSurface(IfcGeometricRepresentationItem* v1_Item, IfcTextureCoordinate* v2_TextureCoordinates) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_TextureCoordinates)); entity = e; EntityBuffer::Add(this); } +IfcAnnotationSurface::IfcAnnotationSurface(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationSurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAnnotationSurface::IfcAnnotationSurface(IfcGeometricRepresentationItem* v1_Item, IfcTextureCoordinate* v2_TextureCoordinates) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_TextureCoordinates)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAnnotationSurfaceOccurrence -bool IfcAnnotationSurfaceOccurrence::is(Type::Enum v) const { return v == Type::IfcAnnotationSurfaceOccurrence || IfcAnnotationOccurrence::is(v); } -Type::Enum IfcAnnotationSurfaceOccurrence::type() const { return Type::IfcAnnotationSurfaceOccurrence; } + + +const IfcParse::entity& IfcAnnotationSurfaceOccurrence::declaration() const { return *IfcAnnotationSurfaceOccurrence_type; } Type::Enum IfcAnnotationSurfaceOccurrence::Class() { return Type::IfcAnnotationSurfaceOccurrence; } -IfcAnnotationSurfaceOccurrence::IfcAnnotationSurfaceOccurrence(IfcAbstractEntity* e) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationSurfaceOccurrence)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAnnotationSurfaceOccurrence::IfcAnnotationSurfaceOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcAnnotationSurfaceOccurrence::IfcAnnotationSurfaceOccurrence(IfcAbstractEntity* e) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationSurfaceOccurrence)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAnnotationSurfaceOccurrence::IfcAnnotationSurfaceOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAnnotationSymbolOccurrence -bool IfcAnnotationSymbolOccurrence::is(Type::Enum v) const { return v == Type::IfcAnnotationSymbolOccurrence || IfcAnnotationOccurrence::is(v); } -Type::Enum IfcAnnotationSymbolOccurrence::type() const { return Type::IfcAnnotationSymbolOccurrence; } + + +const IfcParse::entity& IfcAnnotationSymbolOccurrence::declaration() const { return *IfcAnnotationSymbolOccurrence_type; } Type::Enum IfcAnnotationSymbolOccurrence::Class() { return Type::IfcAnnotationSymbolOccurrence; } -IfcAnnotationSymbolOccurrence::IfcAnnotationSymbolOccurrence(IfcAbstractEntity* e) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationSymbolOccurrence)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAnnotationSymbolOccurrence::IfcAnnotationSymbolOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcAnnotationSymbolOccurrence::IfcAnnotationSymbolOccurrence(IfcAbstractEntity* e) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationSymbolOccurrence)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAnnotationSymbolOccurrence::IfcAnnotationSymbolOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAnnotationTextOccurrence -bool IfcAnnotationTextOccurrence::is(Type::Enum v) const { return v == Type::IfcAnnotationTextOccurrence || IfcAnnotationOccurrence::is(v); } -Type::Enum IfcAnnotationTextOccurrence::type() const { return Type::IfcAnnotationTextOccurrence; } + + +const IfcParse::entity& IfcAnnotationTextOccurrence::declaration() const { return *IfcAnnotationTextOccurrence_type; } Type::Enum IfcAnnotationTextOccurrence::Class() { return Type::IfcAnnotationTextOccurrence; } -IfcAnnotationTextOccurrence::IfcAnnotationTextOccurrence(IfcAbstractEntity* e) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationTextOccurrence)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAnnotationTextOccurrence::IfcAnnotationTextOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcAnnotationTextOccurrence::IfcAnnotationTextOccurrence(IfcAbstractEntity* e) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAnnotationTextOccurrence)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAnnotationTextOccurrence::IfcAnnotationTextOccurrence(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcApplication -IfcOrganization* IfcApplication::ApplicationDeveloper() const { return (IfcOrganization*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcApplication::setApplicationDeveloper(IfcOrganization* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -std::string IfcApplication::Version() const { return *entity->getArgument(1); } -void IfcApplication::setVersion(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -std::string IfcApplication::ApplicationFullName() const { return *entity->getArgument(2); } -void IfcApplication::setApplicationFullName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -std::string IfcApplication::ApplicationIdentifier() const { return *entity->getArgument(3); } -void IfcApplication::setApplicationIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcApplication::is(Type::Enum v) const { return v == Type::IfcApplication; } -Type::Enum IfcApplication::type() const { return Type::IfcApplication; } +IfcOrganization* IfcApplication::ApplicationDeveloper() const { return (IfcOrganization*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcApplication::setApplicationDeveloper(IfcOrganization* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +std::string IfcApplication::Version() const { return *data_->getArgument(1); } +void IfcApplication::setVersion(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +std::string IfcApplication::ApplicationFullName() const { return *data_->getArgument(2); } +void IfcApplication::setApplicationFullName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +std::string IfcApplication::ApplicationIdentifier() const { return *data_->getArgument(3); } +void IfcApplication::setApplicationIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcApplication::declaration() const { return *IfcApplication_type; } Type::Enum IfcApplication::Class() { return Type::IfcApplication; } -IfcApplication::IfcApplication(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcApplication)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcApplication::IfcApplication(IfcOrganization* v1_ApplicationDeveloper, std::string v2_Version, std::string v3_ApplicationFullName, std::string v4_ApplicationIdentifier) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ApplicationDeveloper)); e->setArgument(1,(v2_Version)); e->setArgument(2,(v3_ApplicationFullName)); e->setArgument(3,(v4_ApplicationIdentifier)); entity = e; EntityBuffer::Add(this); } +IfcApplication::IfcApplication(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcApplication)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcApplication::IfcApplication(IfcOrganization* v1_ApplicationDeveloper, std::string v2_Version, std::string v3_ApplicationFullName, std::string v4_ApplicationIdentifier) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ApplicationDeveloper)); e->setArgument(1,(v2_Version)); e->setArgument(2,(v3_ApplicationFullName)); e->setArgument(3,(v4_ApplicationIdentifier)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAppliedValue -bool IfcAppliedValue::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcAppliedValue::Name() const { return *entity->getArgument(0); } -void IfcAppliedValue::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcAppliedValue::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcAppliedValue::Description() const { return *entity->getArgument(1); } -void IfcAppliedValue::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcAppliedValue::hasAppliedValue() const { return !entity->getArgument(2)->isNull(); } -IfcAppliedValueSelect* IfcAppliedValue::AppliedValue() const { return (IfcAppliedValueSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcAppliedValue::setAppliedValue(IfcAppliedValueSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcAppliedValue::hasUnitBasis() const { return !entity->getArgument(3)->isNull(); } -IfcMeasureWithUnit* IfcAppliedValue::UnitBasis() const { return (IfcMeasureWithUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcAppliedValue::setUnitBasis(IfcMeasureWithUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcAppliedValue::hasApplicableDate() const { return !entity->getArgument(4)->isNull(); } -IfcDateTimeSelect* IfcAppliedValue::ApplicableDate() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcAppliedValue::setApplicableDate(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcAppliedValue::hasFixedUntilDate() const { return !entity->getArgument(5)->isNull(); } -IfcDateTimeSelect* IfcAppliedValue::FixedUntilDate() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcAppliedValue::setFixedUntilDate(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcReferencesValueDocument::list::ptr IfcAppliedValue::ValuesReferenced() const { return entity->getInverse(Type::IfcReferencesValueDocument, 1)->as(); } -IfcAppliedValueRelationship::list::ptr IfcAppliedValue::ValueOfComponents() const { return entity->getInverse(Type::IfcAppliedValueRelationship, 0)->as(); } -IfcAppliedValueRelationship::list::ptr IfcAppliedValue::IsComponentIn() const { return entity->getInverse(Type::IfcAppliedValueRelationship, 1)->as(); } -bool IfcAppliedValue::is(Type::Enum v) const { return v == Type::IfcAppliedValue; } -Type::Enum IfcAppliedValue::type() const { return Type::IfcAppliedValue; } +bool IfcAppliedValue::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcAppliedValue::Name() const { return *data_->getArgument(0); } +void IfcAppliedValue::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcAppliedValue::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcAppliedValue::Description() const { return *data_->getArgument(1); } +void IfcAppliedValue::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcAppliedValue::hasAppliedValue() const { return !data_->getArgument(2)->isNull(); } +IfcAppliedValueSelect* IfcAppliedValue::AppliedValue() const { return (IfcAppliedValueSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcAppliedValue::setAppliedValue(IfcAppliedValueSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcAppliedValue::hasUnitBasis() const { return !data_->getArgument(3)->isNull(); } +IfcMeasureWithUnit* IfcAppliedValue::UnitBasis() const { return (IfcMeasureWithUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcAppliedValue::setUnitBasis(IfcMeasureWithUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcAppliedValue::hasApplicableDate() const { return !data_->getArgument(4)->isNull(); } +IfcDateTimeSelect* IfcAppliedValue::ApplicableDate() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcAppliedValue::setApplicableDate(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcAppliedValue::hasFixedUntilDate() const { return !data_->getArgument(5)->isNull(); } +IfcDateTimeSelect* IfcAppliedValue::FixedUntilDate() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcAppliedValue::setFixedUntilDate(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + +IfcReferencesValueDocument::list::ptr IfcAppliedValue::ValuesReferenced() const { return data_->getInverse(Type::IfcReferencesValueDocument, 1)->as(); } +IfcAppliedValueRelationship::list::ptr IfcAppliedValue::ValueOfComponents() const { return data_->getInverse(Type::IfcAppliedValueRelationship, 0)->as(); } +IfcAppliedValueRelationship::list::ptr IfcAppliedValue::IsComponentIn() const { return data_->getInverse(Type::IfcAppliedValueRelationship, 1)->as(); } + +const IfcParse::entity& IfcAppliedValue::declaration() const { return *IfcAppliedValue_type; } Type::Enum IfcAppliedValue::Class() { return Type::IfcAppliedValue; } -IfcAppliedValue::IfcAppliedValue(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcAppliedValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAppliedValue::IfcAppliedValue(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcAppliedValueSelect* v3_AppliedValue, IfcMeasureWithUnit* v4_UnitBasis, IfcDateTimeSelect* v5_ApplicableDate, IfcDateTimeSelect* v6_FixedUntilDate) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_AppliedValue)); e->setArgument(3,(v4_UnitBasis)); e->setArgument(4,(v5_ApplicableDate)); e->setArgument(5,(v6_FixedUntilDate)); entity = e; EntityBuffer::Add(this); } +IfcAppliedValue::IfcAppliedValue(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcAppliedValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAppliedValue::IfcAppliedValue(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcAppliedValueSelect* v3_AppliedValue, IfcMeasureWithUnit* v4_UnitBasis, IfcDateTimeSelect* v5_ApplicableDate, IfcDateTimeSelect* v6_FixedUntilDate) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_AppliedValue)); e->setArgument(3,(v4_UnitBasis)); e->setArgument(4,(v5_ApplicableDate)); e->setArgument(5,(v6_FixedUntilDate)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAppliedValueRelationship -IfcAppliedValue* IfcAppliedValueRelationship::ComponentOfTotal() const { return (IfcAppliedValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcAppliedValueRelationship::setComponentOfTotal(IfcAppliedValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcTemplatedEntityList< IfcAppliedValue >::ptr IfcAppliedValueRelationship::Components() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcAppliedValueRelationship::setComponents(IfcTemplatedEntityList< IfcAppliedValue >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum IfcAppliedValueRelationship::ArithmeticOperator() const { return IfcArithmeticOperatorEnum::FromString(*entity->getArgument(2)); } -void IfcAppliedValueRelationship::setArithmeticOperator(IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v,IfcArithmeticOperatorEnum::ToString(v)); } -bool IfcAppliedValueRelationship::hasName() const { return !entity->getArgument(3)->isNull(); } -std::string IfcAppliedValueRelationship::Name() const { return *entity->getArgument(3); } -void IfcAppliedValueRelationship::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcAppliedValueRelationship::hasDescription() const { return !entity->getArgument(4)->isNull(); } -std::string IfcAppliedValueRelationship::Description() const { return *entity->getArgument(4); } -void IfcAppliedValueRelationship::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcAppliedValueRelationship::is(Type::Enum v) const { return v == Type::IfcAppliedValueRelationship; } -Type::Enum IfcAppliedValueRelationship::type() const { return Type::IfcAppliedValueRelationship; } +IfcAppliedValue* IfcAppliedValueRelationship::ComponentOfTotal() const { return (IfcAppliedValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcAppliedValueRelationship::setComponentOfTotal(IfcAppliedValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcTemplatedEntityList< IfcAppliedValue >::ptr IfcAppliedValueRelationship::Components() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcAppliedValueRelationship::setComponents(IfcTemplatedEntityList< IfcAppliedValue >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum IfcAppliedValueRelationship::ArithmeticOperator() const { return IfcArithmeticOperatorEnum::FromString(*data_->getArgument(2)); } +void IfcAppliedValueRelationship::setArithmeticOperator(IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v,IfcArithmeticOperatorEnum::ToString(v)); } +bool IfcAppliedValueRelationship::hasName() const { return !data_->getArgument(3)->isNull(); } +std::string IfcAppliedValueRelationship::Name() const { return *data_->getArgument(3); } +void IfcAppliedValueRelationship::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcAppliedValueRelationship::hasDescription() const { return !data_->getArgument(4)->isNull(); } +std::string IfcAppliedValueRelationship::Description() const { return *data_->getArgument(4); } +void IfcAppliedValueRelationship::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcAppliedValueRelationship::declaration() const { return *IfcAppliedValueRelationship_type; } Type::Enum IfcAppliedValueRelationship::Class() { return Type::IfcAppliedValueRelationship; } -IfcAppliedValueRelationship::IfcAppliedValueRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcAppliedValueRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAppliedValueRelationship::IfcAppliedValueRelationship(IfcAppliedValue* v1_ComponentOfTotal, IfcTemplatedEntityList< IfcAppliedValue >::ptr v2_Components, IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum v3_ArithmeticOperator, boost::optional< std::string > v4_Name, boost::optional< std::string > v5_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ComponentOfTotal)); e->setArgument(1,(v2_Components)->generalize()); e->setArgument(2,v3_ArithmeticOperator,IfcArithmeticOperatorEnum::ToString(v3_ArithmeticOperator)); if (v4_Name) { e->setArgument(3,(*v4_Name)); } else { e->setArgument(3); } if (v5_Description) { e->setArgument(4,(*v5_Description)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcAppliedValueRelationship::IfcAppliedValueRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcAppliedValueRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAppliedValueRelationship::IfcAppliedValueRelationship(IfcAppliedValue* v1_ComponentOfTotal, IfcTemplatedEntityList< IfcAppliedValue >::ptr v2_Components, IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum v3_ArithmeticOperator, boost::optional< std::string > v4_Name, boost::optional< std::string > v5_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ComponentOfTotal)); e->setArgument(1,(v2_Components)->generalize()); e->setArgument(2,v3_ArithmeticOperator,IfcArithmeticOperatorEnum::ToString(v3_ArithmeticOperator)); if (v4_Name) { e->setArgument(3,(*v4_Name)); } else { e->setArgument(3); } if (v5_Description) { e->setArgument(4,(*v5_Description)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcApproval -bool IfcApproval::hasDescription() const { return !entity->getArgument(0)->isNull(); } -std::string IfcApproval::Description() const { return *entity->getArgument(0); } -void IfcApproval::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcDateTimeSelect* IfcApproval::ApprovalDateTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcApproval::setApprovalDateTime(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcApproval::hasApprovalStatus() const { return !entity->getArgument(2)->isNull(); } -std::string IfcApproval::ApprovalStatus() const { return *entity->getArgument(2); } -void IfcApproval::setApprovalStatus(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcApproval::hasApprovalLevel() const { return !entity->getArgument(3)->isNull(); } -std::string IfcApproval::ApprovalLevel() const { return *entity->getArgument(3); } -void IfcApproval::setApprovalLevel(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcApproval::hasApprovalQualifier() const { return !entity->getArgument(4)->isNull(); } -std::string IfcApproval::ApprovalQualifier() const { return *entity->getArgument(4); } -void IfcApproval::setApprovalQualifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -std::string IfcApproval::Name() const { return *entity->getArgument(5); } -void IfcApproval::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -std::string IfcApproval::Identifier() const { return *entity->getArgument(6); } -void IfcApproval::setIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcApprovalActorRelationship::list::ptr IfcApproval::Actors() const { return entity->getInverse(Type::IfcApprovalActorRelationship, 1)->as(); } -IfcApprovalRelationship::list::ptr IfcApproval::IsRelatedWith() const { return entity->getInverse(Type::IfcApprovalRelationship, 0)->as(); } -IfcApprovalRelationship::list::ptr IfcApproval::Relates() const { return entity->getInverse(Type::IfcApprovalRelationship, 1)->as(); } -bool IfcApproval::is(Type::Enum v) const { return v == Type::IfcApproval; } -Type::Enum IfcApproval::type() const { return Type::IfcApproval; } +bool IfcApproval::hasDescription() const { return !data_->getArgument(0)->isNull(); } +std::string IfcApproval::Description() const { return *data_->getArgument(0); } +void IfcApproval::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcDateTimeSelect* IfcApproval::ApprovalDateTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcApproval::setApprovalDateTime(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcApproval::hasApprovalStatus() const { return !data_->getArgument(2)->isNull(); } +std::string IfcApproval::ApprovalStatus() const { return *data_->getArgument(2); } +void IfcApproval::setApprovalStatus(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcApproval::hasApprovalLevel() const { return !data_->getArgument(3)->isNull(); } +std::string IfcApproval::ApprovalLevel() const { return *data_->getArgument(3); } +void IfcApproval::setApprovalLevel(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcApproval::hasApprovalQualifier() const { return !data_->getArgument(4)->isNull(); } +std::string IfcApproval::ApprovalQualifier() const { return *data_->getArgument(4); } +void IfcApproval::setApprovalQualifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +std::string IfcApproval::Name() const { return *data_->getArgument(5); } +void IfcApproval::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +std::string IfcApproval::Identifier() const { return *data_->getArgument(6); } +void IfcApproval::setIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + +IfcApprovalActorRelationship::list::ptr IfcApproval::Actors() const { return data_->getInverse(Type::IfcApprovalActorRelationship, 1)->as(); } +IfcApprovalRelationship::list::ptr IfcApproval::IsRelatedWith() const { return data_->getInverse(Type::IfcApprovalRelationship, 0)->as(); } +IfcApprovalRelationship::list::ptr IfcApproval::Relates() const { return data_->getInverse(Type::IfcApprovalRelationship, 1)->as(); } + +const IfcParse::entity& IfcApproval::declaration() const { return *IfcApproval_type; } Type::Enum IfcApproval::Class() { return Type::IfcApproval; } -IfcApproval::IfcApproval(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcApproval)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcApproval::IfcApproval(boost::optional< std::string > v1_Description, IfcDateTimeSelect* v2_ApprovalDateTime, boost::optional< std::string > v3_ApprovalStatus, boost::optional< std::string > v4_ApprovalLevel, boost::optional< std::string > v5_ApprovalQualifier, std::string v6_Name, std::string v7_Identifier) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Description) { e->setArgument(0,(*v1_Description)); } else { e->setArgument(0); } e->setArgument(1,(v2_ApprovalDateTime)); if (v3_ApprovalStatus) { e->setArgument(2,(*v3_ApprovalStatus)); } else { e->setArgument(2); } if (v4_ApprovalLevel) { e->setArgument(3,(*v4_ApprovalLevel)); } else { e->setArgument(3); } if (v5_ApprovalQualifier) { e->setArgument(4,(*v5_ApprovalQualifier)); } else { e->setArgument(4); } e->setArgument(5,(v6_Name)); e->setArgument(6,(v7_Identifier)); entity = e; EntityBuffer::Add(this); } +IfcApproval::IfcApproval(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcApproval)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcApproval::IfcApproval(boost::optional< std::string > v1_Description, IfcDateTimeSelect* v2_ApprovalDateTime, boost::optional< std::string > v3_ApprovalStatus, boost::optional< std::string > v4_ApprovalLevel, boost::optional< std::string > v5_ApprovalQualifier, std::string v6_Name, std::string v7_Identifier) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Description) { e->setArgument(0,(*v1_Description)); } else { e->setArgument(0); } e->setArgument(1,(v2_ApprovalDateTime)); if (v3_ApprovalStatus) { e->setArgument(2,(*v3_ApprovalStatus)); } else { e->setArgument(2); } if (v4_ApprovalLevel) { e->setArgument(3,(*v4_ApprovalLevel)); } else { e->setArgument(3); } if (v5_ApprovalQualifier) { e->setArgument(4,(*v5_ApprovalQualifier)); } else { e->setArgument(4); } e->setArgument(5,(v6_Name)); e->setArgument(6,(v7_Identifier)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcApprovalActorRelationship -IfcActorSelect* IfcApprovalActorRelationship::Actor() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcApprovalActorRelationship::setActor(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcApproval* IfcApprovalActorRelationship::Approval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcApprovalActorRelationship::setApproval(IfcApproval* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcActorRole* IfcApprovalActorRelationship::Role() const { return (IfcActorRole*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcApprovalActorRelationship::setRole(IfcActorRole* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcApprovalActorRelationship::is(Type::Enum v) const { return v == Type::IfcApprovalActorRelationship; } -Type::Enum IfcApprovalActorRelationship::type() const { return Type::IfcApprovalActorRelationship; } +IfcActorSelect* IfcApprovalActorRelationship::Actor() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcApprovalActorRelationship::setActor(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcApproval* IfcApprovalActorRelationship::Approval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcApprovalActorRelationship::setApproval(IfcApproval* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcActorRole* IfcApprovalActorRelationship::Role() const { return (IfcActorRole*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcApprovalActorRelationship::setRole(IfcActorRole* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcApprovalActorRelationship::declaration() const { return *IfcApprovalActorRelationship_type; } Type::Enum IfcApprovalActorRelationship::Class() { return Type::IfcApprovalActorRelationship; } -IfcApprovalActorRelationship::IfcApprovalActorRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcApprovalActorRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcApprovalActorRelationship::IfcApprovalActorRelationship(IfcActorSelect* v1_Actor, IfcApproval* v2_Approval, IfcActorRole* v3_Role) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Actor)); e->setArgument(1,(v2_Approval)); e->setArgument(2,(v3_Role)); entity = e; EntityBuffer::Add(this); } +IfcApprovalActorRelationship::IfcApprovalActorRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcApprovalActorRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcApprovalActorRelationship::IfcApprovalActorRelationship(IfcActorSelect* v1_Actor, IfcApproval* v2_Approval, IfcActorRole* v3_Role) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Actor)); e->setArgument(1,(v2_Approval)); e->setArgument(2,(v3_Role)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcApprovalPropertyRelationship -IfcTemplatedEntityList< IfcProperty >::ptr IfcApprovalPropertyRelationship::ApprovedProperties() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcApprovalPropertyRelationship::setApprovedProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -IfcApproval* IfcApprovalPropertyRelationship::Approval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcApprovalPropertyRelationship::setApproval(IfcApproval* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcApprovalPropertyRelationship::is(Type::Enum v) const { return v == Type::IfcApprovalPropertyRelationship; } -Type::Enum IfcApprovalPropertyRelationship::type() const { return Type::IfcApprovalPropertyRelationship; } +IfcTemplatedEntityList< IfcProperty >::ptr IfcApprovalPropertyRelationship::ApprovedProperties() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcApprovalPropertyRelationship::setApprovedProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } +IfcApproval* IfcApprovalPropertyRelationship::Approval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcApprovalPropertyRelationship::setApproval(IfcApproval* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcApprovalPropertyRelationship::declaration() const { return *IfcApprovalPropertyRelationship_type; } Type::Enum IfcApprovalPropertyRelationship::Class() { return Type::IfcApprovalPropertyRelationship; } -IfcApprovalPropertyRelationship::IfcApprovalPropertyRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcApprovalPropertyRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcApprovalPropertyRelationship::IfcApprovalPropertyRelationship(IfcTemplatedEntityList< IfcProperty >::ptr v1_ApprovedProperties, IfcApproval* v2_Approval) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ApprovedProperties)->generalize()); e->setArgument(1,(v2_Approval)); entity = e; EntityBuffer::Add(this); } +IfcApprovalPropertyRelationship::IfcApprovalPropertyRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcApprovalPropertyRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcApprovalPropertyRelationship::IfcApprovalPropertyRelationship(IfcTemplatedEntityList< IfcProperty >::ptr v1_ApprovedProperties, IfcApproval* v2_Approval) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ApprovedProperties)->generalize()); e->setArgument(1,(v2_Approval)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcApprovalRelationship -IfcApproval* IfcApprovalRelationship::RelatedApproval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcApprovalRelationship::setRelatedApproval(IfcApproval* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcApproval* IfcApprovalRelationship::RelatingApproval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcApprovalRelationship::setRelatingApproval(IfcApproval* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcApprovalRelationship::hasDescription() const { return !entity->getArgument(2)->isNull(); } -std::string IfcApprovalRelationship::Description() const { return *entity->getArgument(2); } -void IfcApprovalRelationship::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -std::string IfcApprovalRelationship::Name() const { return *entity->getArgument(3); } -void IfcApprovalRelationship::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcApprovalRelationship::is(Type::Enum v) const { return v == Type::IfcApprovalRelationship; } -Type::Enum IfcApprovalRelationship::type() const { return Type::IfcApprovalRelationship; } +IfcApproval* IfcApprovalRelationship::RelatedApproval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcApprovalRelationship::setRelatedApproval(IfcApproval* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcApproval* IfcApprovalRelationship::RelatingApproval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcApprovalRelationship::setRelatingApproval(IfcApproval* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcApprovalRelationship::hasDescription() const { return !data_->getArgument(2)->isNull(); } +std::string IfcApprovalRelationship::Description() const { return *data_->getArgument(2); } +void IfcApprovalRelationship::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +std::string IfcApprovalRelationship::Name() const { return *data_->getArgument(3); } +void IfcApprovalRelationship::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcApprovalRelationship::declaration() const { return *IfcApprovalRelationship_type; } Type::Enum IfcApprovalRelationship::Class() { return Type::IfcApprovalRelationship; } -IfcApprovalRelationship::IfcApprovalRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcApprovalRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcApprovalRelationship::IfcApprovalRelationship(IfcApproval* v1_RelatedApproval, IfcApproval* v2_RelatingApproval, boost::optional< std::string > v3_Description, std::string v4_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelatedApproval)); e->setArgument(1,(v2_RelatingApproval)); if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } e->setArgument(3,(v4_Name)); entity = e; EntityBuffer::Add(this); } +IfcApprovalRelationship::IfcApprovalRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcApprovalRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcApprovalRelationship::IfcApprovalRelationship(IfcApproval* v1_RelatedApproval, IfcApproval* v2_RelatingApproval, boost::optional< std::string > v3_Description, std::string v4_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelatedApproval)); e->setArgument(1,(v2_RelatingApproval)); if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } e->setArgument(3,(v4_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcArbitraryClosedProfileDef -IfcCurve* IfcArbitraryClosedProfileDef::OuterCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcArbitraryClosedProfileDef::setOuterCurve(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcArbitraryClosedProfileDef::is(Type::Enum v) const { return v == Type::IfcArbitraryClosedProfileDef || IfcProfileDef::is(v); } -Type::Enum IfcArbitraryClosedProfileDef::type() const { return Type::IfcArbitraryClosedProfileDef; } +IfcCurve* IfcArbitraryClosedProfileDef::OuterCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcArbitraryClosedProfileDef::setOuterCurve(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcArbitraryClosedProfileDef::declaration() const { return *IfcArbitraryClosedProfileDef_type; } Type::Enum IfcArbitraryClosedProfileDef::Class() { return Type::IfcArbitraryClosedProfileDef; } -IfcArbitraryClosedProfileDef::IfcArbitraryClosedProfileDef(IfcAbstractEntity* e) : IfcProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcArbitraryClosedProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcArbitraryClosedProfileDef::IfcArbitraryClosedProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcCurve* v3_OuterCurve) : IfcProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_OuterCurve)); entity = e; EntityBuffer::Add(this); } +IfcArbitraryClosedProfileDef::IfcArbitraryClosedProfileDef(IfcAbstractEntity* e) : IfcProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcArbitraryClosedProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcArbitraryClosedProfileDef::IfcArbitraryClosedProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcCurve* v3_OuterCurve) : IfcProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_OuterCurve)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcArbitraryOpenProfileDef -IfcBoundedCurve* IfcArbitraryOpenProfileDef::Curve() const { return (IfcBoundedCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcArbitraryOpenProfileDef::setCurve(IfcBoundedCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcArbitraryOpenProfileDef::is(Type::Enum v) const { return v == Type::IfcArbitraryOpenProfileDef || IfcProfileDef::is(v); } -Type::Enum IfcArbitraryOpenProfileDef::type() const { return Type::IfcArbitraryOpenProfileDef; } +IfcBoundedCurve* IfcArbitraryOpenProfileDef::Curve() const { return (IfcBoundedCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcArbitraryOpenProfileDef::setCurve(IfcBoundedCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcArbitraryOpenProfileDef::declaration() const { return *IfcArbitraryOpenProfileDef_type; } Type::Enum IfcArbitraryOpenProfileDef::Class() { return Type::IfcArbitraryOpenProfileDef; } -IfcArbitraryOpenProfileDef::IfcArbitraryOpenProfileDef(IfcAbstractEntity* e) : IfcProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcArbitraryOpenProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcArbitraryOpenProfileDef::IfcArbitraryOpenProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcBoundedCurve* v3_Curve) : IfcProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Curve)); entity = e; EntityBuffer::Add(this); } +IfcArbitraryOpenProfileDef::IfcArbitraryOpenProfileDef(IfcAbstractEntity* e) : IfcProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcArbitraryOpenProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcArbitraryOpenProfileDef::IfcArbitraryOpenProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcBoundedCurve* v3_Curve) : IfcProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Curve)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcArbitraryProfileDefWithVoids -IfcTemplatedEntityList< IfcCurve >::ptr IfcArbitraryProfileDefWithVoids::InnerCurves() const { IfcEntityList::ptr es = *entity->getArgument(3); return es->as(); } -void IfcArbitraryProfileDefWithVoids::setInnerCurves(IfcTemplatedEntityList< IfcCurve >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v->generalize()); } -bool IfcArbitraryProfileDefWithVoids::is(Type::Enum v) const { return v == Type::IfcArbitraryProfileDefWithVoids || IfcArbitraryClosedProfileDef::is(v); } -Type::Enum IfcArbitraryProfileDefWithVoids::type() const { return Type::IfcArbitraryProfileDefWithVoids; } +IfcTemplatedEntityList< IfcCurve >::ptr IfcArbitraryProfileDefWithVoids::InnerCurves() const { IfcEntityList::ptr es = *data_->getArgument(3); return es->as(); } +void IfcArbitraryProfileDefWithVoids::setInnerCurves(IfcTemplatedEntityList< IfcCurve >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v->generalize()); } + + +const IfcParse::entity& IfcArbitraryProfileDefWithVoids::declaration() const { return *IfcArbitraryProfileDefWithVoids_type; } Type::Enum IfcArbitraryProfileDefWithVoids::Class() { return Type::IfcArbitraryProfileDefWithVoids; } -IfcArbitraryProfileDefWithVoids::IfcArbitraryProfileDefWithVoids(IfcAbstractEntity* e) : IfcArbitraryClosedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcArbitraryProfileDefWithVoids)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcArbitraryProfileDefWithVoids::IfcArbitraryProfileDefWithVoids(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcCurve* v3_OuterCurve, IfcTemplatedEntityList< IfcCurve >::ptr v4_InnerCurves) : IfcArbitraryClosedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_OuterCurve)); e->setArgument(3,(v4_InnerCurves)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcArbitraryProfileDefWithVoids::IfcArbitraryProfileDefWithVoids(IfcAbstractEntity* e) : IfcArbitraryClosedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcArbitraryProfileDefWithVoids)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcArbitraryProfileDefWithVoids::IfcArbitraryProfileDefWithVoids(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcCurve* v3_OuterCurve, IfcTemplatedEntityList< IfcCurve >::ptr v4_InnerCurves) : IfcArbitraryClosedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_OuterCurve)); e->setArgument(3,(v4_InnerCurves)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAsset -std::string IfcAsset::AssetID() const { return *entity->getArgument(5); } -void IfcAsset::setAssetID(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcCostValue* IfcAsset::OriginalValue() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcAsset::setOriginalValue(IfcCostValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcCostValue* IfcAsset::CurrentValue() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcAsset::setCurrentValue(IfcCostValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcCostValue* IfcAsset::TotalReplacementCost() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcAsset::setTotalReplacementCost(IfcCostValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -IfcActorSelect* IfcAsset::Owner() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcAsset::setOwner(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -IfcActorSelect* IfcAsset::User() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcAsset::setUser(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -IfcPerson* IfcAsset::ResponsiblePerson() const { return (IfcPerson*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(11))); } -void IfcAsset::setResponsiblePerson(IfcPerson* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -IfcCalendarDate* IfcAsset::IncorporationDate() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(12))); } -void IfcAsset::setIncorporationDate(IfcCalendarDate* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -IfcCostValue* IfcAsset::DepreciatedValue() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(13))); } -void IfcAsset::setDepreciatedValue(IfcCostValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcAsset::is(Type::Enum v) const { return v == Type::IfcAsset || IfcGroup::is(v); } -Type::Enum IfcAsset::type() const { return Type::IfcAsset; } +std::string IfcAsset::AssetID() const { return *data_->getArgument(5); } +void IfcAsset::setAssetID(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +IfcCostValue* IfcAsset::OriginalValue() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcAsset::setOriginalValue(IfcCostValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +IfcCostValue* IfcAsset::CurrentValue() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcAsset::setCurrentValue(IfcCostValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +IfcCostValue* IfcAsset::TotalReplacementCost() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcAsset::setTotalReplacementCost(IfcCostValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +IfcActorSelect* IfcAsset::Owner() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcAsset::setOwner(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +IfcActorSelect* IfcAsset::User() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcAsset::setUser(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +IfcPerson* IfcAsset::ResponsiblePerson() const { return (IfcPerson*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(11))); } +void IfcAsset::setResponsiblePerson(IfcPerson* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +IfcCalendarDate* IfcAsset::IncorporationDate() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(12))); } +void IfcAsset::setIncorporationDate(IfcCalendarDate* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +IfcCostValue* IfcAsset::DepreciatedValue() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(13))); } +void IfcAsset::setDepreciatedValue(IfcCostValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } + + +const IfcParse::entity& IfcAsset::declaration() const { return *IfcAsset_type; } Type::Enum IfcAsset::Class() { return Type::IfcAsset; } -IfcAsset::IfcAsset(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAsset)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAsset::IfcAsset(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_AssetID, IfcCostValue* v7_OriginalValue, IfcCostValue* v8_CurrentValue, IfcCostValue* v9_TotalReplacementCost, IfcActorSelect* v10_Owner, IfcActorSelect* v11_User, IfcPerson* v12_ResponsiblePerson, IfcCalendarDate* v13_IncorporationDate, IfcCostValue* v14_DepreciatedValue) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_AssetID)); e->setArgument(6,(v7_OriginalValue)); e->setArgument(7,(v8_CurrentValue)); e->setArgument(8,(v9_TotalReplacementCost)); e->setArgument(9,(v10_Owner)); e->setArgument(10,(v11_User)); e->setArgument(11,(v12_ResponsiblePerson)); e->setArgument(12,(v13_IncorporationDate)); e->setArgument(13,(v14_DepreciatedValue)); entity = e; EntityBuffer::Add(this); } +IfcAsset::IfcAsset(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAsset)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAsset::IfcAsset(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_AssetID, IfcCostValue* v7_OriginalValue, IfcCostValue* v8_CurrentValue, IfcCostValue* v9_TotalReplacementCost, IfcActorSelect* v10_Owner, IfcActorSelect* v11_User, IfcPerson* v12_ResponsiblePerson, IfcCalendarDate* v13_IncorporationDate, IfcCostValue* v14_DepreciatedValue) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_AssetID)); e->setArgument(6,(v7_OriginalValue)); e->setArgument(7,(v8_CurrentValue)); e->setArgument(8,(v9_TotalReplacementCost)); e->setArgument(9,(v10_Owner)); e->setArgument(10,(v11_User)); e->setArgument(11,(v12_ResponsiblePerson)); e->setArgument(12,(v13_IncorporationDate)); e->setArgument(13,(v14_DepreciatedValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAsymmetricIShapeProfileDef -double IfcAsymmetricIShapeProfileDef::TopFlangeWidth() const { return *entity->getArgument(8); } -void IfcAsymmetricIShapeProfileDef::setTopFlangeWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcAsymmetricIShapeProfileDef::hasTopFlangeThickness() const { return !entity->getArgument(9)->isNull(); } -double IfcAsymmetricIShapeProfileDef::TopFlangeThickness() const { return *entity->getArgument(9); } -void IfcAsymmetricIShapeProfileDef::setTopFlangeThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcAsymmetricIShapeProfileDef::hasTopFlangeFilletRadius() const { return !entity->getArgument(10)->isNull(); } -double IfcAsymmetricIShapeProfileDef::TopFlangeFilletRadius() const { return *entity->getArgument(10); } -void IfcAsymmetricIShapeProfileDef::setTopFlangeFilletRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcAsymmetricIShapeProfileDef::hasCentreOfGravityInY() const { return !entity->getArgument(11)->isNull(); } -double IfcAsymmetricIShapeProfileDef::CentreOfGravityInY() const { return *entity->getArgument(11); } -void IfcAsymmetricIShapeProfileDef::setCentreOfGravityInY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcAsymmetricIShapeProfileDef::is(Type::Enum v) const { return v == Type::IfcAsymmetricIShapeProfileDef || IfcIShapeProfileDef::is(v); } -Type::Enum IfcAsymmetricIShapeProfileDef::type() const { return Type::IfcAsymmetricIShapeProfileDef; } +double IfcAsymmetricIShapeProfileDef::TopFlangeWidth() const { return *data_->getArgument(8); } +void IfcAsymmetricIShapeProfileDef::setTopFlangeWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcAsymmetricIShapeProfileDef::hasTopFlangeThickness() const { return !data_->getArgument(9)->isNull(); } +double IfcAsymmetricIShapeProfileDef::TopFlangeThickness() const { return *data_->getArgument(9); } +void IfcAsymmetricIShapeProfileDef::setTopFlangeThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcAsymmetricIShapeProfileDef::hasTopFlangeFilletRadius() const { return !data_->getArgument(10)->isNull(); } +double IfcAsymmetricIShapeProfileDef::TopFlangeFilletRadius() const { return *data_->getArgument(10); } +void IfcAsymmetricIShapeProfileDef::setTopFlangeFilletRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcAsymmetricIShapeProfileDef::hasCentreOfGravityInY() const { return !data_->getArgument(11)->isNull(); } +double IfcAsymmetricIShapeProfileDef::CentreOfGravityInY() const { return *data_->getArgument(11); } +void IfcAsymmetricIShapeProfileDef::setCentreOfGravityInY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } + + +const IfcParse::entity& IfcAsymmetricIShapeProfileDef::declaration() const { return *IfcAsymmetricIShapeProfileDef_type; } Type::Enum IfcAsymmetricIShapeProfileDef::Class() { return Type::IfcAsymmetricIShapeProfileDef; } -IfcAsymmetricIShapeProfileDef::IfcAsymmetricIShapeProfileDef(IfcAbstractEntity* e) : IfcIShapeProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAsymmetricIShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAsymmetricIShapeProfileDef::IfcAsymmetricIShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallWidth, double v5_OverallDepth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, double v9_TopFlangeWidth, boost::optional< double > v10_TopFlangeThickness, boost::optional< double > v11_TopFlangeFilletRadius, boost::optional< double > v12_CentreOfGravityInY) : IfcIShapeProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_OverallWidth)); e->setArgument(4,(v5_OverallDepth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_FlangeThickness)); if (v8_FilletRadius) { e->setArgument(7,(*v8_FilletRadius)); } else { e->setArgument(7); } e->setArgument(8,(v9_TopFlangeWidth)); if (v10_TopFlangeThickness) { e->setArgument(9,(*v10_TopFlangeThickness)); } else { e->setArgument(9); } if (v11_TopFlangeFilletRadius) { e->setArgument(10,(*v11_TopFlangeFilletRadius)); } else { e->setArgument(10); } if (v12_CentreOfGravityInY) { e->setArgument(11,(*v12_CentreOfGravityInY)); } else { e->setArgument(11); } entity = e; EntityBuffer::Add(this); } +IfcAsymmetricIShapeProfileDef::IfcAsymmetricIShapeProfileDef(IfcAbstractEntity* e) : IfcIShapeProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAsymmetricIShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAsymmetricIShapeProfileDef::IfcAsymmetricIShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallWidth, double v5_OverallDepth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, double v9_TopFlangeWidth, boost::optional< double > v10_TopFlangeThickness, boost::optional< double > v11_TopFlangeFilletRadius, boost::optional< double > v12_CentreOfGravityInY) : IfcIShapeProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_OverallWidth)); e->setArgument(4,(v5_OverallDepth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_FlangeThickness)); if (v8_FilletRadius) { e->setArgument(7,(*v8_FilletRadius)); } else { e->setArgument(7); } e->setArgument(8,(v9_TopFlangeWidth)); if (v10_TopFlangeThickness) { e->setArgument(9,(*v10_TopFlangeThickness)); } else { e->setArgument(9); } if (v11_TopFlangeFilletRadius) { e->setArgument(10,(*v11_TopFlangeFilletRadius)); } else { e->setArgument(10); } if (v12_CentreOfGravityInY) { e->setArgument(11,(*v12_CentreOfGravityInY)); } else { e->setArgument(11); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAxis1Placement -bool IfcAxis1Placement::hasAxis() const { return !entity->getArgument(1)->isNull(); } -IfcDirection* IfcAxis1Placement::Axis() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcAxis1Placement::setAxis(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcAxis1Placement::is(Type::Enum v) const { return v == Type::IfcAxis1Placement || IfcPlacement::is(v); } -Type::Enum IfcAxis1Placement::type() const { return Type::IfcAxis1Placement; } +bool IfcAxis1Placement::hasAxis() const { return !data_->getArgument(1)->isNull(); } +IfcDirection* IfcAxis1Placement::Axis() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcAxis1Placement::setAxis(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcAxis1Placement::declaration() const { return *IfcAxis1Placement_type; } Type::Enum IfcAxis1Placement::Class() { return Type::IfcAxis1Placement; } -IfcAxis1Placement::IfcAxis1Placement(IfcAbstractEntity* e) : IfcPlacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAxis1Placement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAxis1Placement::IfcAxis1Placement(IfcCartesianPoint* v1_Location, IfcDirection* v2_Axis) : IfcPlacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Location)); e->setArgument(1,(v2_Axis)); entity = e; EntityBuffer::Add(this); } +IfcAxis1Placement::IfcAxis1Placement(IfcAbstractEntity* e) : IfcPlacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAxis1Placement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAxis1Placement::IfcAxis1Placement(IfcCartesianPoint* v1_Location, IfcDirection* v2_Axis) : IfcPlacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Location)); e->setArgument(1,(v2_Axis)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAxis2Placement2D -bool IfcAxis2Placement2D::hasRefDirection() const { return !entity->getArgument(1)->isNull(); } -IfcDirection* IfcAxis2Placement2D::RefDirection() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcAxis2Placement2D::setRefDirection(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcAxis2Placement2D::is(Type::Enum v) const { return v == Type::IfcAxis2Placement2D || IfcPlacement::is(v); } -Type::Enum IfcAxis2Placement2D::type() const { return Type::IfcAxis2Placement2D; } +bool IfcAxis2Placement2D::hasRefDirection() const { return !data_->getArgument(1)->isNull(); } +IfcDirection* IfcAxis2Placement2D::RefDirection() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcAxis2Placement2D::setRefDirection(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcAxis2Placement2D::declaration() const { return *IfcAxis2Placement2D_type; } Type::Enum IfcAxis2Placement2D::Class() { return Type::IfcAxis2Placement2D; } -IfcAxis2Placement2D::IfcAxis2Placement2D(IfcAbstractEntity* e) : IfcPlacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAxis2Placement2D)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAxis2Placement2D::IfcAxis2Placement2D(IfcCartesianPoint* v1_Location, IfcDirection* v2_RefDirection) : IfcPlacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Location)); e->setArgument(1,(v2_RefDirection)); entity = e; EntityBuffer::Add(this); } +IfcAxis2Placement2D::IfcAxis2Placement2D(IfcAbstractEntity* e) : IfcPlacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAxis2Placement2D)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAxis2Placement2D::IfcAxis2Placement2D(IfcCartesianPoint* v1_Location, IfcDirection* v2_RefDirection) : IfcPlacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Location)); e->setArgument(1,(v2_RefDirection)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAxis2Placement3D -bool IfcAxis2Placement3D::hasAxis() const { return !entity->getArgument(1)->isNull(); } -IfcDirection* IfcAxis2Placement3D::Axis() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcAxis2Placement3D::setAxis(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcAxis2Placement3D::hasRefDirection() const { return !entity->getArgument(2)->isNull(); } -IfcDirection* IfcAxis2Placement3D::RefDirection() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcAxis2Placement3D::setRefDirection(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcAxis2Placement3D::is(Type::Enum v) const { return v == Type::IfcAxis2Placement3D || IfcPlacement::is(v); } -Type::Enum IfcAxis2Placement3D::type() const { return Type::IfcAxis2Placement3D; } +bool IfcAxis2Placement3D::hasAxis() const { return !data_->getArgument(1)->isNull(); } +IfcDirection* IfcAxis2Placement3D::Axis() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcAxis2Placement3D::setAxis(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcAxis2Placement3D::hasRefDirection() const { return !data_->getArgument(2)->isNull(); } +IfcDirection* IfcAxis2Placement3D::RefDirection() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcAxis2Placement3D::setRefDirection(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcAxis2Placement3D::declaration() const { return *IfcAxis2Placement3D_type; } Type::Enum IfcAxis2Placement3D::Class() { return Type::IfcAxis2Placement3D; } -IfcAxis2Placement3D::IfcAxis2Placement3D(IfcAbstractEntity* e) : IfcPlacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAxis2Placement3D)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAxis2Placement3D::IfcAxis2Placement3D(IfcCartesianPoint* v1_Location, IfcDirection* v2_Axis, IfcDirection* v3_RefDirection) : IfcPlacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Location)); e->setArgument(1,(v2_Axis)); e->setArgument(2,(v3_RefDirection)); entity = e; EntityBuffer::Add(this); } +IfcAxis2Placement3D::IfcAxis2Placement3D(IfcAbstractEntity* e) : IfcPlacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAxis2Placement3D)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAxis2Placement3D::IfcAxis2Placement3D(IfcCartesianPoint* v1_Location, IfcDirection* v2_Axis, IfcDirection* v3_RefDirection) : IfcPlacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Location)); e->setArgument(1,(v2_Axis)); e->setArgument(2,(v3_RefDirection)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBSplineCurve -int IfcBSplineCurve::Degree() const { return *entity->getArgument(0); } -void IfcBSplineCurve::setDegree(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcTemplatedEntityList< IfcCartesianPoint >::ptr IfcBSplineCurve::ControlPointsList() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcBSplineCurve::setControlPointsList(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -IfcBSplineCurveForm::IfcBSplineCurveForm IfcBSplineCurve::CurveForm() const { return IfcBSplineCurveForm::FromString(*entity->getArgument(2)); } -void IfcBSplineCurve::setCurveForm(IfcBSplineCurveForm::IfcBSplineCurveForm v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v,IfcBSplineCurveForm::ToString(v)); } -bool IfcBSplineCurve::ClosedCurve() const { return *entity->getArgument(3); } -void IfcBSplineCurve::setClosedCurve(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcBSplineCurve::SelfIntersect() const { return *entity->getArgument(4); } -void IfcBSplineCurve::setSelfIntersect(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcBSplineCurve::is(Type::Enum v) const { return v == Type::IfcBSplineCurve || IfcBoundedCurve::is(v); } -Type::Enum IfcBSplineCurve::type() const { return Type::IfcBSplineCurve; } +int IfcBSplineCurve::Degree() const { return *data_->getArgument(0); } +void IfcBSplineCurve::setDegree(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcTemplatedEntityList< IfcCartesianPoint >::ptr IfcBSplineCurve::ControlPointsList() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcBSplineCurve::setControlPointsList(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +IfcBSplineCurveForm::IfcBSplineCurveForm IfcBSplineCurve::CurveForm() const { return IfcBSplineCurveForm::FromString(*data_->getArgument(2)); } +void IfcBSplineCurve::setCurveForm(IfcBSplineCurveForm::IfcBSplineCurveForm v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v,IfcBSplineCurveForm::ToString(v)); } +bool IfcBSplineCurve::ClosedCurve() const { return *data_->getArgument(3); } +void IfcBSplineCurve::setClosedCurve(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcBSplineCurve::SelfIntersect() const { return *data_->getArgument(4); } +void IfcBSplineCurve::setSelfIntersect(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcBSplineCurve::declaration() const { return *IfcBSplineCurve_type; } Type::Enum IfcBSplineCurve::Class() { return Type::IfcBSplineCurve; } -IfcBSplineCurve::IfcBSplineCurve(IfcAbstractEntity* e) : IfcBoundedCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBSplineCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBSplineCurve::IfcBSplineCurve(int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect) : IfcBoundedCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Degree)); e->setArgument(1,(v2_ControlPointsList)->generalize()); e->setArgument(2,v3_CurveForm,IfcBSplineCurveForm::ToString(v3_CurveForm)); e->setArgument(3,(v4_ClosedCurve)); e->setArgument(4,(v5_SelfIntersect)); entity = e; EntityBuffer::Add(this); } +IfcBSplineCurve::IfcBSplineCurve(IfcAbstractEntity* e) : IfcBoundedCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBSplineCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBSplineCurve::IfcBSplineCurve(int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect) : IfcBoundedCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Degree)); e->setArgument(1,(v2_ControlPointsList)->generalize()); e->setArgument(2,v3_CurveForm,IfcBSplineCurveForm::ToString(v3_CurveForm)); e->setArgument(3,(v4_ClosedCurve)); e->setArgument(4,(v5_SelfIntersect)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBeam -bool IfcBeam::is(Type::Enum v) const { return v == Type::IfcBeam || IfcBuildingElement::is(v); } -Type::Enum IfcBeam::type() const { return Type::IfcBeam; } + + +const IfcParse::entity& IfcBeam::declaration() const { return *IfcBeam_type; } Type::Enum IfcBeam::Class() { return Type::IfcBeam; } -IfcBeam::IfcBeam(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBeam)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBeam::IfcBeam(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcBeam::IfcBeam(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBeam)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBeam::IfcBeam(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBeamType -IfcBeamTypeEnum::IfcBeamTypeEnum IfcBeamType::PredefinedType() const { return IfcBeamTypeEnum::FromString(*entity->getArgument(9)); } -void IfcBeamType::setPredefinedType(IfcBeamTypeEnum::IfcBeamTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcBeamTypeEnum::ToString(v)); } -bool IfcBeamType::is(Type::Enum v) const { return v == Type::IfcBeamType || IfcBuildingElementType::is(v); } -Type::Enum IfcBeamType::type() const { return Type::IfcBeamType; } +IfcBeamTypeEnum::IfcBeamTypeEnum IfcBeamType::PredefinedType() const { return IfcBeamTypeEnum::FromString(*data_->getArgument(9)); } +void IfcBeamType::setPredefinedType(IfcBeamTypeEnum::IfcBeamTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcBeamTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcBeamType::declaration() const { return *IfcBeamType_type; } Type::Enum IfcBeamType::Class() { return Type::IfcBeamType; } -IfcBeamType::IfcBeamType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBeamType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBeamType::IfcBeamType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBeamTypeEnum::IfcBeamTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcBeamTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcBeamType::IfcBeamType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBeamType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBeamType::IfcBeamType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBeamTypeEnum::IfcBeamTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcBeamTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBezierCurve -bool IfcBezierCurve::is(Type::Enum v) const { return v == Type::IfcBezierCurve || IfcBSplineCurve::is(v); } -Type::Enum IfcBezierCurve::type() const { return Type::IfcBezierCurve; } + + +const IfcParse::entity& IfcBezierCurve::declaration() const { return *IfcBezierCurve_type; } Type::Enum IfcBezierCurve::Class() { return Type::IfcBezierCurve; } -IfcBezierCurve::IfcBezierCurve(IfcAbstractEntity* e) : IfcBSplineCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBezierCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBezierCurve::IfcBezierCurve(int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect) : IfcBSplineCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Degree)); e->setArgument(1,(v2_ControlPointsList)->generalize()); e->setArgument(2,v3_CurveForm,IfcBSplineCurveForm::ToString(v3_CurveForm)); e->setArgument(3,(v4_ClosedCurve)); e->setArgument(4,(v5_SelfIntersect)); entity = e; EntityBuffer::Add(this); } +IfcBezierCurve::IfcBezierCurve(IfcAbstractEntity* e) : IfcBSplineCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBezierCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBezierCurve::IfcBezierCurve(int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect) : IfcBSplineCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Degree)); e->setArgument(1,(v2_ControlPointsList)->generalize()); e->setArgument(2,v3_CurveForm,IfcBSplineCurveForm::ToString(v3_CurveForm)); e->setArgument(3,(v4_ClosedCurve)); e->setArgument(4,(v5_SelfIntersect)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBlobTexture -std::string IfcBlobTexture::RasterFormat() const { return *entity->getArgument(4); } -void IfcBlobTexture::setRasterFormat(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcBlobTexture::RasterCode() const { return *entity->getArgument(5); } -void IfcBlobTexture::setRasterCode(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcBlobTexture::is(Type::Enum v) const { return v == Type::IfcBlobTexture || IfcSurfaceTexture::is(v); } -Type::Enum IfcBlobTexture::type() const { return Type::IfcBlobTexture; } +std::string IfcBlobTexture::RasterFormat() const { return *data_->getArgument(4); } +void IfcBlobTexture::setRasterFormat(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcBlobTexture::RasterCode() const { return *data_->getArgument(5); } +void IfcBlobTexture::setRasterCode(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcBlobTexture::declaration() const { return *IfcBlobTexture_type; } Type::Enum IfcBlobTexture::Class() { return Type::IfcBlobTexture; } -IfcBlobTexture::IfcBlobTexture(IfcAbstractEntity* e) : IfcSurfaceTexture((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBlobTexture)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBlobTexture::IfcBlobTexture(bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform, std::string v5_RasterFormat, bool v6_RasterCode) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); e->setArgument(2,v3_TextureType,IfcSurfaceTextureEnum::ToString(v3_TextureType)); e->setArgument(3,(v4_TextureTransform)); e->setArgument(4,(v5_RasterFormat)); e->setArgument(5,(v6_RasterCode)); entity = e; EntityBuffer::Add(this); } +IfcBlobTexture::IfcBlobTexture(IfcAbstractEntity* e) : IfcSurfaceTexture((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBlobTexture)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBlobTexture::IfcBlobTexture(bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform, std::string v5_RasterFormat, bool v6_RasterCode) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); e->setArgument(2,v3_TextureType,IfcSurfaceTextureEnum::ToString(v3_TextureType)); e->setArgument(3,(v4_TextureTransform)); e->setArgument(4,(v5_RasterFormat)); e->setArgument(5,(v6_RasterCode)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBlock -double IfcBlock::XLength() const { return *entity->getArgument(1); } -void IfcBlock::setXLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcBlock::YLength() const { return *entity->getArgument(2); } -void IfcBlock::setYLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -double IfcBlock::ZLength() const { return *entity->getArgument(3); } -void IfcBlock::setZLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcBlock::is(Type::Enum v) const { return v == Type::IfcBlock || IfcCsgPrimitive3D::is(v); } -Type::Enum IfcBlock::type() const { return Type::IfcBlock; } +double IfcBlock::XLength() const { return *data_->getArgument(1); } +void IfcBlock::setXLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcBlock::YLength() const { return *data_->getArgument(2); } +void IfcBlock::setYLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +double IfcBlock::ZLength() const { return *data_->getArgument(3); } +void IfcBlock::setZLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcBlock::declaration() const { return *IfcBlock_type; } Type::Enum IfcBlock::Class() { return Type::IfcBlock; } -IfcBlock::IfcBlock(IfcAbstractEntity* e) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBlock)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBlock::IfcBlock(IfcAxis2Placement3D* v1_Position, double v2_XLength, double v3_YLength, double v4_ZLength) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_XLength)); e->setArgument(2,(v3_YLength)); e->setArgument(3,(v4_ZLength)); entity = e; EntityBuffer::Add(this); } +IfcBlock::IfcBlock(IfcAbstractEntity* e) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBlock)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBlock::IfcBlock(IfcAxis2Placement3D* v1_Position, double v2_XLength, double v3_YLength, double v4_ZLength) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_XLength)); e->setArgument(2,(v3_YLength)); e->setArgument(3,(v4_ZLength)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoilerType -IfcBoilerTypeEnum::IfcBoilerTypeEnum IfcBoilerType::PredefinedType() const { return IfcBoilerTypeEnum::FromString(*entity->getArgument(9)); } -void IfcBoilerType::setPredefinedType(IfcBoilerTypeEnum::IfcBoilerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcBoilerTypeEnum::ToString(v)); } -bool IfcBoilerType::is(Type::Enum v) const { return v == Type::IfcBoilerType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcBoilerType::type() const { return Type::IfcBoilerType; } +IfcBoilerTypeEnum::IfcBoilerTypeEnum IfcBoilerType::PredefinedType() const { return IfcBoilerTypeEnum::FromString(*data_->getArgument(9)); } +void IfcBoilerType::setPredefinedType(IfcBoilerTypeEnum::IfcBoilerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcBoilerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcBoilerType::declaration() const { return *IfcBoilerType_type; } Type::Enum IfcBoilerType::Class() { return Type::IfcBoilerType; } -IfcBoilerType::IfcBoilerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoilerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoilerType::IfcBoilerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBoilerTypeEnum::IfcBoilerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcBoilerTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcBoilerType::IfcBoilerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoilerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoilerType::IfcBoilerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBoilerTypeEnum::IfcBoilerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcBoilerTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBooleanClippingResult -bool IfcBooleanClippingResult::is(Type::Enum v) const { return v == Type::IfcBooleanClippingResult || IfcBooleanResult::is(v); } -Type::Enum IfcBooleanClippingResult::type() const { return Type::IfcBooleanClippingResult; } + + +const IfcParse::entity& IfcBooleanClippingResult::declaration() const { return *IfcBooleanClippingResult_type; } Type::Enum IfcBooleanClippingResult::Class() { return Type::IfcBooleanClippingResult; } -IfcBooleanClippingResult::IfcBooleanClippingResult(IfcAbstractEntity* e) : IfcBooleanResult((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBooleanClippingResult)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBooleanClippingResult::IfcBooleanClippingResult(IfcBooleanOperator::IfcBooleanOperator v1_Operator, IfcBooleanOperand* v2_FirstOperand, IfcBooleanOperand* v3_SecondOperand) : IfcBooleanResult((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_Operator,IfcBooleanOperator::ToString(v1_Operator)); e->setArgument(1,(v2_FirstOperand)); e->setArgument(2,(v3_SecondOperand)); entity = e; EntityBuffer::Add(this); } +IfcBooleanClippingResult::IfcBooleanClippingResult(IfcAbstractEntity* e) : IfcBooleanResult((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBooleanClippingResult)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBooleanClippingResult::IfcBooleanClippingResult(IfcBooleanOperator::IfcBooleanOperator v1_Operator, IfcBooleanOperand* v2_FirstOperand, IfcBooleanOperand* v3_SecondOperand) : IfcBooleanResult((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_Operator,IfcBooleanOperator::ToString(v1_Operator)); e->setArgument(1,(v2_FirstOperand)); e->setArgument(2,(v3_SecondOperand)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBooleanResult -IfcBooleanOperator::IfcBooleanOperator IfcBooleanResult::Operator() const { return IfcBooleanOperator::FromString(*entity->getArgument(0)); } -void IfcBooleanResult::setOperator(IfcBooleanOperator::IfcBooleanOperator v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v,IfcBooleanOperator::ToString(v)); } -IfcBooleanOperand* IfcBooleanResult::FirstOperand() const { return (IfcBooleanOperand*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcBooleanResult::setFirstOperand(IfcBooleanOperand* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcBooleanOperand* IfcBooleanResult::SecondOperand() const { return (IfcBooleanOperand*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcBooleanResult::setSecondOperand(IfcBooleanOperand* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcBooleanResult::is(Type::Enum v) const { return v == Type::IfcBooleanResult || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcBooleanResult::type() const { return Type::IfcBooleanResult; } +IfcBooleanOperator::IfcBooleanOperator IfcBooleanResult::Operator() const { return IfcBooleanOperator::FromString(*data_->getArgument(0)); } +void IfcBooleanResult::setOperator(IfcBooleanOperator::IfcBooleanOperator v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v,IfcBooleanOperator::ToString(v)); } +IfcBooleanOperand* IfcBooleanResult::FirstOperand() const { return (IfcBooleanOperand*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcBooleanResult::setFirstOperand(IfcBooleanOperand* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcBooleanOperand* IfcBooleanResult::SecondOperand() const { return (IfcBooleanOperand*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcBooleanResult::setSecondOperand(IfcBooleanOperand* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcBooleanResult::declaration() const { return *IfcBooleanResult_type; } Type::Enum IfcBooleanResult::Class() { return Type::IfcBooleanResult; } -IfcBooleanResult::IfcBooleanResult(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBooleanResult)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBooleanResult::IfcBooleanResult(IfcBooleanOperator::IfcBooleanOperator v1_Operator, IfcBooleanOperand* v2_FirstOperand, IfcBooleanOperand* v3_SecondOperand) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_Operator,IfcBooleanOperator::ToString(v1_Operator)); e->setArgument(1,(v2_FirstOperand)); e->setArgument(2,(v3_SecondOperand)); entity = e; EntityBuffer::Add(this); } +IfcBooleanResult::IfcBooleanResult(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBooleanResult)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBooleanResult::IfcBooleanResult(IfcBooleanOperator::IfcBooleanOperator v1_Operator, IfcBooleanOperand* v2_FirstOperand, IfcBooleanOperand* v3_SecondOperand) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_Operator,IfcBooleanOperator::ToString(v1_Operator)); e->setArgument(1,(v2_FirstOperand)); e->setArgument(2,(v3_SecondOperand)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoundaryCondition -bool IfcBoundaryCondition::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcBoundaryCondition::Name() const { return *entity->getArgument(0); } -void IfcBoundaryCondition::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcBoundaryCondition::is(Type::Enum v) const { return v == Type::IfcBoundaryCondition; } -Type::Enum IfcBoundaryCondition::type() const { return Type::IfcBoundaryCondition; } +bool IfcBoundaryCondition::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcBoundaryCondition::Name() const { return *data_->getArgument(0); } +void IfcBoundaryCondition::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcBoundaryCondition::declaration() const { return *IfcBoundaryCondition_type; } Type::Enum IfcBoundaryCondition::Class() { return Type::IfcBoundaryCondition; } -IfcBoundaryCondition::IfcBoundaryCondition(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcBoundaryCondition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoundaryCondition::IfcBoundaryCondition(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } entity = e; EntityBuffer::Add(this); } +IfcBoundaryCondition::IfcBoundaryCondition(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcBoundaryCondition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoundaryCondition::IfcBoundaryCondition(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoundaryEdgeCondition -bool IfcBoundaryEdgeCondition::hasLinearStiffnessByLengthX() const { return !entity->getArgument(1)->isNull(); } -double IfcBoundaryEdgeCondition::LinearStiffnessByLengthX() const { return *entity->getArgument(1); } -void IfcBoundaryEdgeCondition::setLinearStiffnessByLengthX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcBoundaryEdgeCondition::hasLinearStiffnessByLengthY() const { return !entity->getArgument(2)->isNull(); } -double IfcBoundaryEdgeCondition::LinearStiffnessByLengthY() const { return *entity->getArgument(2); } -void IfcBoundaryEdgeCondition::setLinearStiffnessByLengthY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcBoundaryEdgeCondition::hasLinearStiffnessByLengthZ() const { return !entity->getArgument(3)->isNull(); } -double IfcBoundaryEdgeCondition::LinearStiffnessByLengthZ() const { return *entity->getArgument(3); } -void IfcBoundaryEdgeCondition::setLinearStiffnessByLengthZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthX() const { return !entity->getArgument(4)->isNull(); } -double IfcBoundaryEdgeCondition::RotationalStiffnessByLengthX() const { return *entity->getArgument(4); } -void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthY() const { return !entity->getArgument(5)->isNull(); } -double IfcBoundaryEdgeCondition::RotationalStiffnessByLengthY() const { return *entity->getArgument(5); } -void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthZ() const { return !entity->getArgument(6)->isNull(); } -double IfcBoundaryEdgeCondition::RotationalStiffnessByLengthZ() const { return *entity->getArgument(6); } -void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcBoundaryEdgeCondition::is(Type::Enum v) const { return v == Type::IfcBoundaryEdgeCondition || IfcBoundaryCondition::is(v); } -Type::Enum IfcBoundaryEdgeCondition::type() const { return Type::IfcBoundaryEdgeCondition; } +bool IfcBoundaryEdgeCondition::hasLinearStiffnessByLengthX() const { return !data_->getArgument(1)->isNull(); } +double IfcBoundaryEdgeCondition::LinearStiffnessByLengthX() const { return *data_->getArgument(1); } +void IfcBoundaryEdgeCondition::setLinearStiffnessByLengthX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcBoundaryEdgeCondition::hasLinearStiffnessByLengthY() const { return !data_->getArgument(2)->isNull(); } +double IfcBoundaryEdgeCondition::LinearStiffnessByLengthY() const { return *data_->getArgument(2); } +void IfcBoundaryEdgeCondition::setLinearStiffnessByLengthY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcBoundaryEdgeCondition::hasLinearStiffnessByLengthZ() const { return !data_->getArgument(3)->isNull(); } +double IfcBoundaryEdgeCondition::LinearStiffnessByLengthZ() const { return *data_->getArgument(3); } +void IfcBoundaryEdgeCondition::setLinearStiffnessByLengthZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthX() const { return !data_->getArgument(4)->isNull(); } +double IfcBoundaryEdgeCondition::RotationalStiffnessByLengthX() const { return *data_->getArgument(4); } +void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthY() const { return !data_->getArgument(5)->isNull(); } +double IfcBoundaryEdgeCondition::RotationalStiffnessByLengthY() const { return *data_->getArgument(5); } +void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthZ() const { return !data_->getArgument(6)->isNull(); } +double IfcBoundaryEdgeCondition::RotationalStiffnessByLengthZ() const { return *data_->getArgument(6); } +void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcBoundaryEdgeCondition::declaration() const { return *IfcBoundaryEdgeCondition_type; } Type::Enum IfcBoundaryEdgeCondition::Class() { return Type::IfcBoundaryEdgeCondition; } -IfcBoundaryEdgeCondition::IfcBoundaryEdgeCondition(IfcAbstractEntity* e) : IfcBoundaryCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundaryEdgeCondition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoundaryEdgeCondition::IfcBoundaryEdgeCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessByLengthX, boost::optional< double > v3_LinearStiffnessByLengthY, boost::optional< double > v4_LinearStiffnessByLengthZ, boost::optional< double > v5_RotationalStiffnessByLengthX, boost::optional< double > v6_RotationalStiffnessByLengthY, boost::optional< double > v7_RotationalStiffnessByLengthZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_LinearStiffnessByLengthX) { e->setArgument(1,(*v2_LinearStiffnessByLengthX)); } else { e->setArgument(1); } if (v3_LinearStiffnessByLengthY) { e->setArgument(2,(*v3_LinearStiffnessByLengthY)); } else { e->setArgument(2); } if (v4_LinearStiffnessByLengthZ) { e->setArgument(3,(*v4_LinearStiffnessByLengthZ)); } else { e->setArgument(3); } if (v5_RotationalStiffnessByLengthX) { e->setArgument(4,(*v5_RotationalStiffnessByLengthX)); } else { e->setArgument(4); } if (v6_RotationalStiffnessByLengthY) { e->setArgument(5,(*v6_RotationalStiffnessByLengthY)); } else { e->setArgument(5); } if (v7_RotationalStiffnessByLengthZ) { e->setArgument(6,(*v7_RotationalStiffnessByLengthZ)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcBoundaryEdgeCondition::IfcBoundaryEdgeCondition(IfcAbstractEntity* e) : IfcBoundaryCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundaryEdgeCondition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoundaryEdgeCondition::IfcBoundaryEdgeCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessByLengthX, boost::optional< double > v3_LinearStiffnessByLengthY, boost::optional< double > v4_LinearStiffnessByLengthZ, boost::optional< double > v5_RotationalStiffnessByLengthX, boost::optional< double > v6_RotationalStiffnessByLengthY, boost::optional< double > v7_RotationalStiffnessByLengthZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_LinearStiffnessByLengthX) { e->setArgument(1,(*v2_LinearStiffnessByLengthX)); } else { e->setArgument(1); } if (v3_LinearStiffnessByLengthY) { e->setArgument(2,(*v3_LinearStiffnessByLengthY)); } else { e->setArgument(2); } if (v4_LinearStiffnessByLengthZ) { e->setArgument(3,(*v4_LinearStiffnessByLengthZ)); } else { e->setArgument(3); } if (v5_RotationalStiffnessByLengthX) { e->setArgument(4,(*v5_RotationalStiffnessByLengthX)); } else { e->setArgument(4); } if (v6_RotationalStiffnessByLengthY) { e->setArgument(5,(*v6_RotationalStiffnessByLengthY)); } else { e->setArgument(5); } if (v7_RotationalStiffnessByLengthZ) { e->setArgument(6,(*v7_RotationalStiffnessByLengthZ)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoundaryFaceCondition -bool IfcBoundaryFaceCondition::hasLinearStiffnessByAreaX() const { return !entity->getArgument(1)->isNull(); } -double IfcBoundaryFaceCondition::LinearStiffnessByAreaX() const { return *entity->getArgument(1); } -void IfcBoundaryFaceCondition::setLinearStiffnessByAreaX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcBoundaryFaceCondition::hasLinearStiffnessByAreaY() const { return !entity->getArgument(2)->isNull(); } -double IfcBoundaryFaceCondition::LinearStiffnessByAreaY() const { return *entity->getArgument(2); } -void IfcBoundaryFaceCondition::setLinearStiffnessByAreaY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcBoundaryFaceCondition::hasLinearStiffnessByAreaZ() const { return !entity->getArgument(3)->isNull(); } -double IfcBoundaryFaceCondition::LinearStiffnessByAreaZ() const { return *entity->getArgument(3); } -void IfcBoundaryFaceCondition::setLinearStiffnessByAreaZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcBoundaryFaceCondition::is(Type::Enum v) const { return v == Type::IfcBoundaryFaceCondition || IfcBoundaryCondition::is(v); } -Type::Enum IfcBoundaryFaceCondition::type() const { return Type::IfcBoundaryFaceCondition; } +bool IfcBoundaryFaceCondition::hasLinearStiffnessByAreaX() const { return !data_->getArgument(1)->isNull(); } +double IfcBoundaryFaceCondition::LinearStiffnessByAreaX() const { return *data_->getArgument(1); } +void IfcBoundaryFaceCondition::setLinearStiffnessByAreaX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcBoundaryFaceCondition::hasLinearStiffnessByAreaY() const { return !data_->getArgument(2)->isNull(); } +double IfcBoundaryFaceCondition::LinearStiffnessByAreaY() const { return *data_->getArgument(2); } +void IfcBoundaryFaceCondition::setLinearStiffnessByAreaY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcBoundaryFaceCondition::hasLinearStiffnessByAreaZ() const { return !data_->getArgument(3)->isNull(); } +double IfcBoundaryFaceCondition::LinearStiffnessByAreaZ() const { return *data_->getArgument(3); } +void IfcBoundaryFaceCondition::setLinearStiffnessByAreaZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcBoundaryFaceCondition::declaration() const { return *IfcBoundaryFaceCondition_type; } Type::Enum IfcBoundaryFaceCondition::Class() { return Type::IfcBoundaryFaceCondition; } -IfcBoundaryFaceCondition::IfcBoundaryFaceCondition(IfcAbstractEntity* e) : IfcBoundaryCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundaryFaceCondition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoundaryFaceCondition::IfcBoundaryFaceCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessByAreaX, boost::optional< double > v3_LinearStiffnessByAreaY, boost::optional< double > v4_LinearStiffnessByAreaZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_LinearStiffnessByAreaX) { e->setArgument(1,(*v2_LinearStiffnessByAreaX)); } else { e->setArgument(1); } if (v3_LinearStiffnessByAreaY) { e->setArgument(2,(*v3_LinearStiffnessByAreaY)); } else { e->setArgument(2); } if (v4_LinearStiffnessByAreaZ) { e->setArgument(3,(*v4_LinearStiffnessByAreaZ)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcBoundaryFaceCondition::IfcBoundaryFaceCondition(IfcAbstractEntity* e) : IfcBoundaryCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundaryFaceCondition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoundaryFaceCondition::IfcBoundaryFaceCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessByAreaX, boost::optional< double > v3_LinearStiffnessByAreaY, boost::optional< double > v4_LinearStiffnessByAreaZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_LinearStiffnessByAreaX) { e->setArgument(1,(*v2_LinearStiffnessByAreaX)); } else { e->setArgument(1); } if (v3_LinearStiffnessByAreaY) { e->setArgument(2,(*v3_LinearStiffnessByAreaY)); } else { e->setArgument(2); } if (v4_LinearStiffnessByAreaZ) { e->setArgument(3,(*v4_LinearStiffnessByAreaZ)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoundaryNodeCondition -bool IfcBoundaryNodeCondition::hasLinearStiffnessX() const { return !entity->getArgument(1)->isNull(); } -double IfcBoundaryNodeCondition::LinearStiffnessX() const { return *entity->getArgument(1); } -void IfcBoundaryNodeCondition::setLinearStiffnessX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcBoundaryNodeCondition::hasLinearStiffnessY() const { return !entity->getArgument(2)->isNull(); } -double IfcBoundaryNodeCondition::LinearStiffnessY() const { return *entity->getArgument(2); } -void IfcBoundaryNodeCondition::setLinearStiffnessY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcBoundaryNodeCondition::hasLinearStiffnessZ() const { return !entity->getArgument(3)->isNull(); } -double IfcBoundaryNodeCondition::LinearStiffnessZ() const { return *entity->getArgument(3); } -void IfcBoundaryNodeCondition::setLinearStiffnessZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcBoundaryNodeCondition::hasRotationalStiffnessX() const { return !entity->getArgument(4)->isNull(); } -double IfcBoundaryNodeCondition::RotationalStiffnessX() const { return *entity->getArgument(4); } -void IfcBoundaryNodeCondition::setRotationalStiffnessX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcBoundaryNodeCondition::hasRotationalStiffnessY() const { return !entity->getArgument(5)->isNull(); } -double IfcBoundaryNodeCondition::RotationalStiffnessY() const { return *entity->getArgument(5); } -void IfcBoundaryNodeCondition::setRotationalStiffnessY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcBoundaryNodeCondition::hasRotationalStiffnessZ() const { return !entity->getArgument(6)->isNull(); } -double IfcBoundaryNodeCondition::RotationalStiffnessZ() const { return *entity->getArgument(6); } -void IfcBoundaryNodeCondition::setRotationalStiffnessZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcBoundaryNodeCondition::is(Type::Enum v) const { return v == Type::IfcBoundaryNodeCondition || IfcBoundaryCondition::is(v); } -Type::Enum IfcBoundaryNodeCondition::type() const { return Type::IfcBoundaryNodeCondition; } +bool IfcBoundaryNodeCondition::hasLinearStiffnessX() const { return !data_->getArgument(1)->isNull(); } +double IfcBoundaryNodeCondition::LinearStiffnessX() const { return *data_->getArgument(1); } +void IfcBoundaryNodeCondition::setLinearStiffnessX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcBoundaryNodeCondition::hasLinearStiffnessY() const { return !data_->getArgument(2)->isNull(); } +double IfcBoundaryNodeCondition::LinearStiffnessY() const { return *data_->getArgument(2); } +void IfcBoundaryNodeCondition::setLinearStiffnessY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcBoundaryNodeCondition::hasLinearStiffnessZ() const { return !data_->getArgument(3)->isNull(); } +double IfcBoundaryNodeCondition::LinearStiffnessZ() const { return *data_->getArgument(3); } +void IfcBoundaryNodeCondition::setLinearStiffnessZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcBoundaryNodeCondition::hasRotationalStiffnessX() const { return !data_->getArgument(4)->isNull(); } +double IfcBoundaryNodeCondition::RotationalStiffnessX() const { return *data_->getArgument(4); } +void IfcBoundaryNodeCondition::setRotationalStiffnessX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcBoundaryNodeCondition::hasRotationalStiffnessY() const { return !data_->getArgument(5)->isNull(); } +double IfcBoundaryNodeCondition::RotationalStiffnessY() const { return *data_->getArgument(5); } +void IfcBoundaryNodeCondition::setRotationalStiffnessY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcBoundaryNodeCondition::hasRotationalStiffnessZ() const { return !data_->getArgument(6)->isNull(); } +double IfcBoundaryNodeCondition::RotationalStiffnessZ() const { return *data_->getArgument(6); } +void IfcBoundaryNodeCondition::setRotationalStiffnessZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcBoundaryNodeCondition::declaration() const { return *IfcBoundaryNodeCondition_type; } Type::Enum IfcBoundaryNodeCondition::Class() { return Type::IfcBoundaryNodeCondition; } -IfcBoundaryNodeCondition::IfcBoundaryNodeCondition(IfcAbstractEntity* e) : IfcBoundaryCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundaryNodeCondition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoundaryNodeCondition::IfcBoundaryNodeCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessX, boost::optional< double > v3_LinearStiffnessY, boost::optional< double > v4_LinearStiffnessZ, boost::optional< double > v5_RotationalStiffnessX, boost::optional< double > v6_RotationalStiffnessY, boost::optional< double > v7_RotationalStiffnessZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_LinearStiffnessX) { e->setArgument(1,(*v2_LinearStiffnessX)); } else { e->setArgument(1); } if (v3_LinearStiffnessY) { e->setArgument(2,(*v3_LinearStiffnessY)); } else { e->setArgument(2); } if (v4_LinearStiffnessZ) { e->setArgument(3,(*v4_LinearStiffnessZ)); } else { e->setArgument(3); } if (v5_RotationalStiffnessX) { e->setArgument(4,(*v5_RotationalStiffnessX)); } else { e->setArgument(4); } if (v6_RotationalStiffnessY) { e->setArgument(5,(*v6_RotationalStiffnessY)); } else { e->setArgument(5); } if (v7_RotationalStiffnessZ) { e->setArgument(6,(*v7_RotationalStiffnessZ)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcBoundaryNodeCondition::IfcBoundaryNodeCondition(IfcAbstractEntity* e) : IfcBoundaryCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundaryNodeCondition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoundaryNodeCondition::IfcBoundaryNodeCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessX, boost::optional< double > v3_LinearStiffnessY, boost::optional< double > v4_LinearStiffnessZ, boost::optional< double > v5_RotationalStiffnessX, boost::optional< double > v6_RotationalStiffnessY, boost::optional< double > v7_RotationalStiffnessZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_LinearStiffnessX) { e->setArgument(1,(*v2_LinearStiffnessX)); } else { e->setArgument(1); } if (v3_LinearStiffnessY) { e->setArgument(2,(*v3_LinearStiffnessY)); } else { e->setArgument(2); } if (v4_LinearStiffnessZ) { e->setArgument(3,(*v4_LinearStiffnessZ)); } else { e->setArgument(3); } if (v5_RotationalStiffnessX) { e->setArgument(4,(*v5_RotationalStiffnessX)); } else { e->setArgument(4); } if (v6_RotationalStiffnessY) { e->setArgument(5,(*v6_RotationalStiffnessY)); } else { e->setArgument(5); } if (v7_RotationalStiffnessZ) { e->setArgument(6,(*v7_RotationalStiffnessZ)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoundaryNodeConditionWarping -bool IfcBoundaryNodeConditionWarping::hasWarpingStiffness() const { return !entity->getArgument(7)->isNull(); } -double IfcBoundaryNodeConditionWarping::WarpingStiffness() const { return *entity->getArgument(7); } -void IfcBoundaryNodeConditionWarping::setWarpingStiffness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcBoundaryNodeConditionWarping::is(Type::Enum v) const { return v == Type::IfcBoundaryNodeConditionWarping || IfcBoundaryNodeCondition::is(v); } -Type::Enum IfcBoundaryNodeConditionWarping::type() const { return Type::IfcBoundaryNodeConditionWarping; } +bool IfcBoundaryNodeConditionWarping::hasWarpingStiffness() const { return !data_->getArgument(7)->isNull(); } +double IfcBoundaryNodeConditionWarping::WarpingStiffness() const { return *data_->getArgument(7); } +void IfcBoundaryNodeConditionWarping::setWarpingStiffness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcBoundaryNodeConditionWarping::declaration() const { return *IfcBoundaryNodeConditionWarping_type; } Type::Enum IfcBoundaryNodeConditionWarping::Class() { return Type::IfcBoundaryNodeConditionWarping; } -IfcBoundaryNodeConditionWarping::IfcBoundaryNodeConditionWarping(IfcAbstractEntity* e) : IfcBoundaryNodeCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundaryNodeConditionWarping)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoundaryNodeConditionWarping::IfcBoundaryNodeConditionWarping(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessX, boost::optional< double > v3_LinearStiffnessY, boost::optional< double > v4_LinearStiffnessZ, boost::optional< double > v5_RotationalStiffnessX, boost::optional< double > v6_RotationalStiffnessY, boost::optional< double > v7_RotationalStiffnessZ, boost::optional< double > v8_WarpingStiffness) : IfcBoundaryNodeCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_LinearStiffnessX) { e->setArgument(1,(*v2_LinearStiffnessX)); } else { e->setArgument(1); } if (v3_LinearStiffnessY) { e->setArgument(2,(*v3_LinearStiffnessY)); } else { e->setArgument(2); } if (v4_LinearStiffnessZ) { e->setArgument(3,(*v4_LinearStiffnessZ)); } else { e->setArgument(3); } if (v5_RotationalStiffnessX) { e->setArgument(4,(*v5_RotationalStiffnessX)); } else { e->setArgument(4); } if (v6_RotationalStiffnessY) { e->setArgument(5,(*v6_RotationalStiffnessY)); } else { e->setArgument(5); } if (v7_RotationalStiffnessZ) { e->setArgument(6,(*v7_RotationalStiffnessZ)); } else { e->setArgument(6); } if (v8_WarpingStiffness) { e->setArgument(7,(*v8_WarpingStiffness)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcBoundaryNodeConditionWarping::IfcBoundaryNodeConditionWarping(IfcAbstractEntity* e) : IfcBoundaryNodeCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundaryNodeConditionWarping)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoundaryNodeConditionWarping::IfcBoundaryNodeConditionWarping(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessX, boost::optional< double > v3_LinearStiffnessY, boost::optional< double > v4_LinearStiffnessZ, boost::optional< double > v5_RotationalStiffnessX, boost::optional< double > v6_RotationalStiffnessY, boost::optional< double > v7_RotationalStiffnessZ, boost::optional< double > v8_WarpingStiffness) : IfcBoundaryNodeCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_LinearStiffnessX) { e->setArgument(1,(*v2_LinearStiffnessX)); } else { e->setArgument(1); } if (v3_LinearStiffnessY) { e->setArgument(2,(*v3_LinearStiffnessY)); } else { e->setArgument(2); } if (v4_LinearStiffnessZ) { e->setArgument(3,(*v4_LinearStiffnessZ)); } else { e->setArgument(3); } if (v5_RotationalStiffnessX) { e->setArgument(4,(*v5_RotationalStiffnessX)); } else { e->setArgument(4); } if (v6_RotationalStiffnessY) { e->setArgument(5,(*v6_RotationalStiffnessY)); } else { e->setArgument(5); } if (v7_RotationalStiffnessZ) { e->setArgument(6,(*v7_RotationalStiffnessZ)); } else { e->setArgument(6); } if (v8_WarpingStiffness) { e->setArgument(7,(*v8_WarpingStiffness)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoundedCurve -bool IfcBoundedCurve::is(Type::Enum v) const { return v == Type::IfcBoundedCurve || IfcCurve::is(v); } -Type::Enum IfcBoundedCurve::type() const { return Type::IfcBoundedCurve; } + + +const IfcParse::entity& IfcBoundedCurve::declaration() const { return *IfcBoundedCurve_type; } Type::Enum IfcBoundedCurve::Class() { return Type::IfcBoundedCurve; } -IfcBoundedCurve::IfcBoundedCurve(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundedCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoundedCurve::IfcBoundedCurve() : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcBoundedCurve::IfcBoundedCurve(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundedCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoundedCurve::IfcBoundedCurve() : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoundedSurface -bool IfcBoundedSurface::is(Type::Enum v) const { return v == Type::IfcBoundedSurface || IfcSurface::is(v); } -Type::Enum IfcBoundedSurface::type() const { return Type::IfcBoundedSurface; } + + +const IfcParse::entity& IfcBoundedSurface::declaration() const { return *IfcBoundedSurface_type; } Type::Enum IfcBoundedSurface::Class() { return Type::IfcBoundedSurface; } -IfcBoundedSurface::IfcBoundedSurface(IfcAbstractEntity* e) : IfcSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundedSurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoundedSurface::IfcBoundedSurface() : IfcSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcBoundedSurface::IfcBoundedSurface(IfcAbstractEntity* e) : IfcSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundedSurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoundedSurface::IfcBoundedSurface() : IfcSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoundingBox -IfcCartesianPoint* IfcBoundingBox::Corner() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcBoundingBox::setCorner(IfcCartesianPoint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcBoundingBox::XDim() const { return *entity->getArgument(1); } -void IfcBoundingBox::setXDim(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcBoundingBox::YDim() const { return *entity->getArgument(2); } -void IfcBoundingBox::setYDim(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -double IfcBoundingBox::ZDim() const { return *entity->getArgument(3); } -void IfcBoundingBox::setZDim(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcBoundingBox::is(Type::Enum v) const { return v == Type::IfcBoundingBox || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcBoundingBox::type() const { return Type::IfcBoundingBox; } +IfcCartesianPoint* IfcBoundingBox::Corner() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcBoundingBox::setCorner(IfcCartesianPoint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcBoundingBox::XDim() const { return *data_->getArgument(1); } +void IfcBoundingBox::setXDim(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcBoundingBox::YDim() const { return *data_->getArgument(2); } +void IfcBoundingBox::setYDim(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +double IfcBoundingBox::ZDim() const { return *data_->getArgument(3); } +void IfcBoundingBox::setZDim(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcBoundingBox::declaration() const { return *IfcBoundingBox_type; } Type::Enum IfcBoundingBox::Class() { return Type::IfcBoundingBox; } -IfcBoundingBox::IfcBoundingBox(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundingBox)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoundingBox::IfcBoundingBox(IfcCartesianPoint* v1_Corner, double v2_XDim, double v3_YDim, double v4_ZDim) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Corner)); e->setArgument(1,(v2_XDim)); e->setArgument(2,(v3_YDim)); e->setArgument(3,(v4_ZDim)); entity = e; EntityBuffer::Add(this); } +IfcBoundingBox::IfcBoundingBox(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundingBox)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoundingBox::IfcBoundingBox(IfcCartesianPoint* v1_Corner, double v2_XDim, double v3_YDim, double v4_ZDim) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Corner)); e->setArgument(1,(v2_XDim)); e->setArgument(2,(v3_YDim)); e->setArgument(3,(v4_ZDim)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoxedHalfSpace -IfcBoundingBox* IfcBoxedHalfSpace::Enclosure() const { return (IfcBoundingBox*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcBoxedHalfSpace::setEnclosure(IfcBoundingBox* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcBoxedHalfSpace::is(Type::Enum v) const { return v == Type::IfcBoxedHalfSpace || IfcHalfSpaceSolid::is(v); } -Type::Enum IfcBoxedHalfSpace::type() const { return Type::IfcBoxedHalfSpace; } +IfcBoundingBox* IfcBoxedHalfSpace::Enclosure() const { return (IfcBoundingBox*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcBoxedHalfSpace::setEnclosure(IfcBoundingBox* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcBoxedHalfSpace::declaration() const { return *IfcBoxedHalfSpace_type; } Type::Enum IfcBoxedHalfSpace::Class() { return Type::IfcBoxedHalfSpace; } -IfcBoxedHalfSpace::IfcBoxedHalfSpace(IfcAbstractEntity* e) : IfcHalfSpaceSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoxedHalfSpace)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoxedHalfSpace::IfcBoxedHalfSpace(IfcSurface* v1_BaseSurface, bool v2_AgreementFlag, IfcBoundingBox* v3_Enclosure) : IfcHalfSpaceSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BaseSurface)); e->setArgument(1,(v2_AgreementFlag)); e->setArgument(2,(v3_Enclosure)); entity = e; EntityBuffer::Add(this); } +IfcBoxedHalfSpace::IfcBoxedHalfSpace(IfcAbstractEntity* e) : IfcHalfSpaceSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoxedHalfSpace)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoxedHalfSpace::IfcBoxedHalfSpace(IfcSurface* v1_BaseSurface, bool v2_AgreementFlag, IfcBoundingBox* v3_Enclosure) : IfcHalfSpaceSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BaseSurface)); e->setArgument(1,(v2_AgreementFlag)); e->setArgument(2,(v3_Enclosure)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBuilding -bool IfcBuilding::hasElevationOfRefHeight() const { return !entity->getArgument(9)->isNull(); } -double IfcBuilding::ElevationOfRefHeight() const { return *entity->getArgument(9); } -void IfcBuilding::setElevationOfRefHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcBuilding::hasElevationOfTerrain() const { return !entity->getArgument(10)->isNull(); } -double IfcBuilding::ElevationOfTerrain() const { return *entity->getArgument(10); } -void IfcBuilding::setElevationOfTerrain(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcBuilding::hasBuildingAddress() const { return !entity->getArgument(11)->isNull(); } -IfcPostalAddress* IfcBuilding::BuildingAddress() const { return (IfcPostalAddress*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(11))); } -void IfcBuilding::setBuildingAddress(IfcPostalAddress* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcBuilding::is(Type::Enum v) const { return v == Type::IfcBuilding || IfcSpatialStructureElement::is(v); } -Type::Enum IfcBuilding::type() const { return Type::IfcBuilding; } +bool IfcBuilding::hasElevationOfRefHeight() const { return !data_->getArgument(9)->isNull(); } +double IfcBuilding::ElevationOfRefHeight() const { return *data_->getArgument(9); } +void IfcBuilding::setElevationOfRefHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcBuilding::hasElevationOfTerrain() const { return !data_->getArgument(10)->isNull(); } +double IfcBuilding::ElevationOfTerrain() const { return *data_->getArgument(10); } +void IfcBuilding::setElevationOfTerrain(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcBuilding::hasBuildingAddress() const { return !data_->getArgument(11)->isNull(); } +IfcPostalAddress* IfcBuilding::BuildingAddress() const { return (IfcPostalAddress*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(11))); } +void IfcBuilding::setBuildingAddress(IfcPostalAddress* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } + + +const IfcParse::entity& IfcBuilding::declaration() const { return *IfcBuilding_type; } Type::Enum IfcBuilding::Class() { return Type::IfcBuilding; } -IfcBuilding::IfcBuilding(IfcAbstractEntity* e) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuilding)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBuilding::IfcBuilding(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, boost::optional< double > v10_ElevationOfRefHeight, boost::optional< double > v11_ElevationOfTerrain, IfcPostalAddress* v12_BuildingAddress) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_LongName) { e->setArgument(7,(*v8_LongName)); } else { e->setArgument(7); } e->setArgument(8,v9_CompositionType,IfcElementCompositionEnum::ToString(v9_CompositionType)); if (v10_ElevationOfRefHeight) { e->setArgument(9,(*v10_ElevationOfRefHeight)); } else { e->setArgument(9); } if (v11_ElevationOfTerrain) { e->setArgument(10,(*v11_ElevationOfTerrain)); } else { e->setArgument(10); } e->setArgument(11,(v12_BuildingAddress)); entity = e; EntityBuffer::Add(this); } +IfcBuilding::IfcBuilding(IfcAbstractEntity* e) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuilding)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBuilding::IfcBuilding(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, boost::optional< double > v10_ElevationOfRefHeight, boost::optional< double > v11_ElevationOfTerrain, IfcPostalAddress* v12_BuildingAddress) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_LongName) { e->setArgument(7,(*v8_LongName)); } else { e->setArgument(7); } e->setArgument(8,v9_CompositionType,IfcElementCompositionEnum::ToString(v9_CompositionType)); if (v10_ElevationOfRefHeight) { e->setArgument(9,(*v10_ElevationOfRefHeight)); } else { e->setArgument(9); } if (v11_ElevationOfTerrain) { e->setArgument(10,(*v11_ElevationOfTerrain)); } else { e->setArgument(10); } e->setArgument(11,(v12_BuildingAddress)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBuildingElement -bool IfcBuildingElement::is(Type::Enum v) const { return v == Type::IfcBuildingElement || IfcElement::is(v); } -Type::Enum IfcBuildingElement::type() const { return Type::IfcBuildingElement; } + + +const IfcParse::entity& IfcBuildingElement::declaration() const { return *IfcBuildingElement_type; } Type::Enum IfcBuildingElement::Class() { return Type::IfcBuildingElement; } -IfcBuildingElement::IfcBuildingElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBuildingElement::IfcBuildingElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcBuildingElement::IfcBuildingElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBuildingElement::IfcBuildingElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBuildingElementComponent -bool IfcBuildingElementComponent::is(Type::Enum v) const { return v == Type::IfcBuildingElementComponent || IfcBuildingElement::is(v); } -Type::Enum IfcBuildingElementComponent::type() const { return Type::IfcBuildingElementComponent; } + + +const IfcParse::entity& IfcBuildingElementComponent::declaration() const { return *IfcBuildingElementComponent_type; } Type::Enum IfcBuildingElementComponent::Class() { return Type::IfcBuildingElementComponent; } -IfcBuildingElementComponent::IfcBuildingElementComponent(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementComponent)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBuildingElementComponent::IfcBuildingElementComponent(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcBuildingElementComponent::IfcBuildingElementComponent(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementComponent)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBuildingElementComponent::IfcBuildingElementComponent(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBuildingElementPart -bool IfcBuildingElementPart::is(Type::Enum v) const { return v == Type::IfcBuildingElementPart || IfcBuildingElementComponent::is(v); } -Type::Enum IfcBuildingElementPart::type() const { return Type::IfcBuildingElementPart; } + + +const IfcParse::entity& IfcBuildingElementPart::declaration() const { return *IfcBuildingElementPart_type; } Type::Enum IfcBuildingElementPart::Class() { return Type::IfcBuildingElementPart; } -IfcBuildingElementPart::IfcBuildingElementPart(IfcAbstractEntity* e) : IfcBuildingElementComponent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementPart)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBuildingElementPart::IfcBuildingElementPart(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElementComponent((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcBuildingElementPart::IfcBuildingElementPart(IfcAbstractEntity* e) : IfcBuildingElementComponent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementPart)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBuildingElementPart::IfcBuildingElementPart(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElementComponent((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBuildingElementProxy -bool IfcBuildingElementProxy::hasCompositionType() const { return !entity->getArgument(8)->isNull(); } -IfcElementCompositionEnum::IfcElementCompositionEnum IfcBuildingElementProxy::CompositionType() const { return IfcElementCompositionEnum::FromString(*entity->getArgument(8)); } -void IfcBuildingElementProxy::setCompositionType(IfcElementCompositionEnum::IfcElementCompositionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcElementCompositionEnum::ToString(v)); } -bool IfcBuildingElementProxy::is(Type::Enum v) const { return v == Type::IfcBuildingElementProxy || IfcBuildingElement::is(v); } -Type::Enum IfcBuildingElementProxy::type() const { return Type::IfcBuildingElementProxy; } +bool IfcBuildingElementProxy::hasCompositionType() const { return !data_->getArgument(8)->isNull(); } +IfcElementCompositionEnum::IfcElementCompositionEnum IfcBuildingElementProxy::CompositionType() const { return IfcElementCompositionEnum::FromString(*data_->getArgument(8)); } +void IfcBuildingElementProxy::setCompositionType(IfcElementCompositionEnum::IfcElementCompositionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcElementCompositionEnum::ToString(v)); } + + +const IfcParse::entity& IfcBuildingElementProxy::declaration() const { return *IfcBuildingElementProxy_type; } Type::Enum IfcBuildingElementProxy::Class() { return Type::IfcBuildingElementProxy; } -IfcBuildingElementProxy::IfcBuildingElementProxy(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementProxy)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBuildingElementProxy::IfcBuildingElementProxy(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcElementCompositionEnum::IfcElementCompositionEnum > v9_CompositionType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcBuildingElementProxy::IfcBuildingElementProxy(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementProxy)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBuildingElementProxy::IfcBuildingElementProxy(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcElementCompositionEnum::IfcElementCompositionEnum > v9_CompositionType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBuildingElementProxyType -IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum IfcBuildingElementProxyType::PredefinedType() const { return IfcBuildingElementProxyTypeEnum::FromString(*entity->getArgument(9)); } -void IfcBuildingElementProxyType::setPredefinedType(IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcBuildingElementProxyTypeEnum::ToString(v)); } -bool IfcBuildingElementProxyType::is(Type::Enum v) const { return v == Type::IfcBuildingElementProxyType || IfcBuildingElementType::is(v); } -Type::Enum IfcBuildingElementProxyType::type() const { return Type::IfcBuildingElementProxyType; } +IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum IfcBuildingElementProxyType::PredefinedType() const { return IfcBuildingElementProxyTypeEnum::FromString(*data_->getArgument(9)); } +void IfcBuildingElementProxyType::setPredefinedType(IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcBuildingElementProxyTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcBuildingElementProxyType::declaration() const { return *IfcBuildingElementProxyType_type; } Type::Enum IfcBuildingElementProxyType::Class() { return Type::IfcBuildingElementProxyType; } -IfcBuildingElementProxyType::IfcBuildingElementProxyType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementProxyType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBuildingElementProxyType::IfcBuildingElementProxyType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcBuildingElementProxyTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcBuildingElementProxyType::IfcBuildingElementProxyType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementProxyType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBuildingElementProxyType::IfcBuildingElementProxyType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcBuildingElementProxyTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBuildingElementType -bool IfcBuildingElementType::is(Type::Enum v) const { return v == Type::IfcBuildingElementType || IfcElementType::is(v); } -Type::Enum IfcBuildingElementType::type() const { return Type::IfcBuildingElementType; } + + +const IfcParse::entity& IfcBuildingElementType::declaration() const { return *IfcBuildingElementType_type; } Type::Enum IfcBuildingElementType::Class() { return Type::IfcBuildingElementType; } -IfcBuildingElementType::IfcBuildingElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBuildingElementType::IfcBuildingElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcBuildingElementType::IfcBuildingElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBuildingElementType::IfcBuildingElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBuildingStorey -bool IfcBuildingStorey::hasElevation() const { return !entity->getArgument(9)->isNull(); } -double IfcBuildingStorey::Elevation() const { return *entity->getArgument(9); } -void IfcBuildingStorey::setElevation(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcBuildingStorey::is(Type::Enum v) const { return v == Type::IfcBuildingStorey || IfcSpatialStructureElement::is(v); } -Type::Enum IfcBuildingStorey::type() const { return Type::IfcBuildingStorey; } +bool IfcBuildingStorey::hasElevation() const { return !data_->getArgument(9)->isNull(); } +double IfcBuildingStorey::Elevation() const { return *data_->getArgument(9); } +void IfcBuildingStorey::setElevation(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcBuildingStorey::declaration() const { return *IfcBuildingStorey_type; } Type::Enum IfcBuildingStorey::Class() { return Type::IfcBuildingStorey; } -IfcBuildingStorey::IfcBuildingStorey(IfcAbstractEntity* e) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingStorey)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBuildingStorey::IfcBuildingStorey(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, boost::optional< double > v10_Elevation) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_LongName) { e->setArgument(7,(*v8_LongName)); } else { e->setArgument(7); } e->setArgument(8,v9_CompositionType,IfcElementCompositionEnum::ToString(v9_CompositionType)); if (v10_Elevation) { e->setArgument(9,(*v10_Elevation)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcBuildingStorey::IfcBuildingStorey(IfcAbstractEntity* e) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingStorey)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBuildingStorey::IfcBuildingStorey(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, boost::optional< double > v10_Elevation) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_LongName) { e->setArgument(7,(*v8_LongName)); } else { e->setArgument(7); } e->setArgument(8,v9_CompositionType,IfcElementCompositionEnum::ToString(v9_CompositionType)); if (v10_Elevation) { e->setArgument(9,(*v10_Elevation)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCShapeProfileDef -double IfcCShapeProfileDef::Depth() const { return *entity->getArgument(3); } -void IfcCShapeProfileDef::setDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcCShapeProfileDef::Width() const { return *entity->getArgument(4); } -void IfcCShapeProfileDef::setWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -double IfcCShapeProfileDef::WallThickness() const { return *entity->getArgument(5); } -void IfcCShapeProfileDef::setWallThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcCShapeProfileDef::Girth() const { return *entity->getArgument(6); } -void IfcCShapeProfileDef::setGirth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcCShapeProfileDef::hasInternalFilletRadius() const { return !entity->getArgument(7)->isNull(); } -double IfcCShapeProfileDef::InternalFilletRadius() const { return *entity->getArgument(7); } -void IfcCShapeProfileDef::setInternalFilletRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcCShapeProfileDef::hasCentreOfGravityInX() const { return !entity->getArgument(8)->isNull(); } -double IfcCShapeProfileDef::CentreOfGravityInX() const { return *entity->getArgument(8); } -void IfcCShapeProfileDef::setCentreOfGravityInX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcCShapeProfileDef::is(Type::Enum v) const { return v == Type::IfcCShapeProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcCShapeProfileDef::type() const { return Type::IfcCShapeProfileDef; } +double IfcCShapeProfileDef::Depth() const { return *data_->getArgument(3); } +void IfcCShapeProfileDef::setDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcCShapeProfileDef::Width() const { return *data_->getArgument(4); } +void IfcCShapeProfileDef::setWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +double IfcCShapeProfileDef::WallThickness() const { return *data_->getArgument(5); } +void IfcCShapeProfileDef::setWallThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcCShapeProfileDef::Girth() const { return *data_->getArgument(6); } +void IfcCShapeProfileDef::setGirth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcCShapeProfileDef::hasInternalFilletRadius() const { return !data_->getArgument(7)->isNull(); } +double IfcCShapeProfileDef::InternalFilletRadius() const { return *data_->getArgument(7); } +void IfcCShapeProfileDef::setInternalFilletRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcCShapeProfileDef::hasCentreOfGravityInX() const { return !data_->getArgument(8)->isNull(); } +double IfcCShapeProfileDef::CentreOfGravityInX() const { return *data_->getArgument(8); } +void IfcCShapeProfileDef::setCentreOfGravityInX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcCShapeProfileDef::declaration() const { return *IfcCShapeProfileDef_type; } Type::Enum IfcCShapeProfileDef::Class() { return Type::IfcCShapeProfileDef; } -IfcCShapeProfileDef::IfcCShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCShapeProfileDef::IfcCShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_Width, double v6_WallThickness, double v7_Girth, boost::optional< double > v8_InternalFilletRadius, boost::optional< double > v9_CentreOfGravityInX) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Depth)); e->setArgument(4,(v5_Width)); e->setArgument(5,(v6_WallThickness)); e->setArgument(6,(v7_Girth)); if (v8_InternalFilletRadius) { e->setArgument(7,(*v8_InternalFilletRadius)); } else { e->setArgument(7); } if (v9_CentreOfGravityInX) { e->setArgument(8,(*v9_CentreOfGravityInX)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCShapeProfileDef::IfcCShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCShapeProfileDef::IfcCShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_Width, double v6_WallThickness, double v7_Girth, boost::optional< double > v8_InternalFilletRadius, boost::optional< double > v9_CentreOfGravityInX) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Depth)); e->setArgument(4,(v5_Width)); e->setArgument(5,(v6_WallThickness)); e->setArgument(6,(v7_Girth)); if (v8_InternalFilletRadius) { e->setArgument(7,(*v8_InternalFilletRadius)); } else { e->setArgument(7); } if (v9_CentreOfGravityInX) { e->setArgument(8,(*v9_CentreOfGravityInX)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCableCarrierFittingType -IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum IfcCableCarrierFittingType::PredefinedType() const { return IfcCableCarrierFittingTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCableCarrierFittingType::setPredefinedType(IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCableCarrierFittingTypeEnum::ToString(v)); } -bool IfcCableCarrierFittingType::is(Type::Enum v) const { return v == Type::IfcCableCarrierFittingType || IfcFlowFittingType::is(v); } -Type::Enum IfcCableCarrierFittingType::type() const { return Type::IfcCableCarrierFittingType; } +IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum IfcCableCarrierFittingType::PredefinedType() const { return IfcCableCarrierFittingTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCableCarrierFittingType::setPredefinedType(IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCableCarrierFittingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCableCarrierFittingType::declaration() const { return *IfcCableCarrierFittingType_type; } Type::Enum IfcCableCarrierFittingType::Class() { return Type::IfcCableCarrierFittingType; } -IfcCableCarrierFittingType::IfcCableCarrierFittingType(IfcAbstractEntity* e) : IfcFlowFittingType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableCarrierFittingType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCableCarrierFittingType::IfcCableCarrierFittingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum v10_PredefinedType) : IfcFlowFittingType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCableCarrierFittingTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCableCarrierFittingType::IfcCableCarrierFittingType(IfcAbstractEntity* e) : IfcFlowFittingType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableCarrierFittingType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCableCarrierFittingType::IfcCableCarrierFittingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum v10_PredefinedType) : IfcFlowFittingType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCableCarrierFittingTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCableCarrierSegmentType -IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum IfcCableCarrierSegmentType::PredefinedType() const { return IfcCableCarrierSegmentTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCableCarrierSegmentType::setPredefinedType(IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCableCarrierSegmentTypeEnum::ToString(v)); } -bool IfcCableCarrierSegmentType::is(Type::Enum v) const { return v == Type::IfcCableCarrierSegmentType || IfcFlowSegmentType::is(v); } -Type::Enum IfcCableCarrierSegmentType::type() const { return Type::IfcCableCarrierSegmentType; } +IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum IfcCableCarrierSegmentType::PredefinedType() const { return IfcCableCarrierSegmentTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCableCarrierSegmentType::setPredefinedType(IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCableCarrierSegmentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCableCarrierSegmentType::declaration() const { return *IfcCableCarrierSegmentType_type; } Type::Enum IfcCableCarrierSegmentType::Class() { return Type::IfcCableCarrierSegmentType; } -IfcCableCarrierSegmentType::IfcCableCarrierSegmentType(IfcAbstractEntity* e) : IfcFlowSegmentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableCarrierSegmentType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCableCarrierSegmentType::IfcCableCarrierSegmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum v10_PredefinedType) : IfcFlowSegmentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCableCarrierSegmentTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCableCarrierSegmentType::IfcCableCarrierSegmentType(IfcAbstractEntity* e) : IfcFlowSegmentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableCarrierSegmentType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCableCarrierSegmentType::IfcCableCarrierSegmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum v10_PredefinedType) : IfcFlowSegmentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCableCarrierSegmentTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCableSegmentType -IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum IfcCableSegmentType::PredefinedType() const { return IfcCableSegmentTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCableSegmentType::setPredefinedType(IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCableSegmentTypeEnum::ToString(v)); } -bool IfcCableSegmentType::is(Type::Enum v) const { return v == Type::IfcCableSegmentType || IfcFlowSegmentType::is(v); } -Type::Enum IfcCableSegmentType::type() const { return Type::IfcCableSegmentType; } +IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum IfcCableSegmentType::PredefinedType() const { return IfcCableSegmentTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCableSegmentType::setPredefinedType(IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCableSegmentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCableSegmentType::declaration() const { return *IfcCableSegmentType_type; } Type::Enum IfcCableSegmentType::Class() { return Type::IfcCableSegmentType; } -IfcCableSegmentType::IfcCableSegmentType(IfcAbstractEntity* e) : IfcFlowSegmentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableSegmentType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCableSegmentType::IfcCableSegmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum v10_PredefinedType) : IfcFlowSegmentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCableSegmentTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCableSegmentType::IfcCableSegmentType(IfcAbstractEntity* e) : IfcFlowSegmentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableSegmentType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCableSegmentType::IfcCableSegmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum v10_PredefinedType) : IfcFlowSegmentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCableSegmentTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCalendarDate -int IfcCalendarDate::DayComponent() const { return *entity->getArgument(0); } -void IfcCalendarDate::setDayComponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -int IfcCalendarDate::MonthComponent() const { return *entity->getArgument(1); } -void IfcCalendarDate::setMonthComponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -int IfcCalendarDate::YearComponent() const { return *entity->getArgument(2); } -void IfcCalendarDate::setYearComponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcCalendarDate::is(Type::Enum v) const { return v == Type::IfcCalendarDate; } -Type::Enum IfcCalendarDate::type() const { return Type::IfcCalendarDate; } +int IfcCalendarDate::DayComponent() const { return *data_->getArgument(0); } +void IfcCalendarDate::setDayComponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +int IfcCalendarDate::MonthComponent() const { return *data_->getArgument(1); } +void IfcCalendarDate::setMonthComponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +int IfcCalendarDate::YearComponent() const { return *data_->getArgument(2); } +void IfcCalendarDate::setYearComponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcCalendarDate::declaration() const { return *IfcCalendarDate_type; } Type::Enum IfcCalendarDate::Class() { return Type::IfcCalendarDate; } -IfcCalendarDate::IfcCalendarDate(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCalendarDate)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCalendarDate::IfcCalendarDate(int v1_DayComponent, int v2_MonthComponent, int v3_YearComponent) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DayComponent)); e->setArgument(1,(v2_MonthComponent)); e->setArgument(2,(v3_YearComponent)); entity = e; EntityBuffer::Add(this); } +IfcCalendarDate::IfcCalendarDate(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCalendarDate)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCalendarDate::IfcCalendarDate(int v1_DayComponent, int v2_MonthComponent, int v3_YearComponent) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DayComponent)); e->setArgument(1,(v2_MonthComponent)); e->setArgument(2,(v3_YearComponent)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCartesianPoint -std::vector< double > /*[1:3]*/ IfcCartesianPoint::Coordinates() const { return *entity->getArgument(0); } -void IfcCartesianPoint::setCoordinates(std::vector< double > /*[1:3]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcCartesianPoint::is(Type::Enum v) const { return v == Type::IfcCartesianPoint || IfcPoint::is(v); } -Type::Enum IfcCartesianPoint::type() const { return Type::IfcCartesianPoint; } +std::vector< double > /*[1:3]*/ IfcCartesianPoint::Coordinates() const { return *data_->getArgument(0); } +void IfcCartesianPoint::setCoordinates(std::vector< double > /*[1:3]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcCartesianPoint::declaration() const { return *IfcCartesianPoint_type; } Type::Enum IfcCartesianPoint::Class() { return Type::IfcCartesianPoint; } -IfcCartesianPoint::IfcCartesianPoint(IfcAbstractEntity* e) : IfcPoint((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianPoint)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCartesianPoint::IfcCartesianPoint(std::vector< double > /*[1:3]*/ v1_Coordinates) : IfcPoint((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); entity = e; EntityBuffer::Add(this); } +IfcCartesianPoint::IfcCartesianPoint(IfcAbstractEntity* e) : IfcPoint((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianPoint)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCartesianPoint::IfcCartesianPoint(std::vector< double > /*[1:3]*/ v1_Coordinates) : IfcPoint((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCartesianTransformationOperator -bool IfcCartesianTransformationOperator::hasAxis1() const { return !entity->getArgument(0)->isNull(); } -IfcDirection* IfcCartesianTransformationOperator::Axis1() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcCartesianTransformationOperator::setAxis1(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcCartesianTransformationOperator::hasAxis2() const { return !entity->getArgument(1)->isNull(); } -IfcDirection* IfcCartesianTransformationOperator::Axis2() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcCartesianTransformationOperator::setAxis2(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcCartesianPoint* IfcCartesianTransformationOperator::LocalOrigin() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcCartesianTransformationOperator::setLocalOrigin(IfcCartesianPoint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcCartesianTransformationOperator::hasScale() const { return !entity->getArgument(3)->isNull(); } -double IfcCartesianTransformationOperator::Scale() const { return *entity->getArgument(3); } -void IfcCartesianTransformationOperator::setScale(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcCartesianTransformationOperator::is(Type::Enum v) const { return v == Type::IfcCartesianTransformationOperator || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcCartesianTransformationOperator::type() const { return Type::IfcCartesianTransformationOperator; } +bool IfcCartesianTransformationOperator::hasAxis1() const { return !data_->getArgument(0)->isNull(); } +IfcDirection* IfcCartesianTransformationOperator::Axis1() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcCartesianTransformationOperator::setAxis1(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcCartesianTransformationOperator::hasAxis2() const { return !data_->getArgument(1)->isNull(); } +IfcDirection* IfcCartesianTransformationOperator::Axis2() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcCartesianTransformationOperator::setAxis2(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcCartesianPoint* IfcCartesianTransformationOperator::LocalOrigin() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcCartesianTransformationOperator::setLocalOrigin(IfcCartesianPoint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcCartesianTransformationOperator::hasScale() const { return !data_->getArgument(3)->isNull(); } +double IfcCartesianTransformationOperator::Scale() const { return *data_->getArgument(3); } +void IfcCartesianTransformationOperator::setScale(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcCartesianTransformationOperator::declaration() const { return *IfcCartesianTransformationOperator_type; } Type::Enum IfcCartesianTransformationOperator::Class() { return Type::IfcCartesianTransformationOperator; } -IfcCartesianTransformationOperator::IfcCartesianTransformationOperator(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianTransformationOperator)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCartesianTransformationOperator::IfcCartesianTransformationOperator(IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Axis1)); e->setArgument(1,(v2_Axis2)); e->setArgument(2,(v3_LocalOrigin)); if (v4_Scale) { e->setArgument(3,(*v4_Scale)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcCartesianTransformationOperator::IfcCartesianTransformationOperator(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianTransformationOperator)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCartesianTransformationOperator::IfcCartesianTransformationOperator(IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Axis1)); e->setArgument(1,(v2_Axis2)); e->setArgument(2,(v3_LocalOrigin)); if (v4_Scale) { e->setArgument(3,(*v4_Scale)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCartesianTransformationOperator2D -bool IfcCartesianTransformationOperator2D::is(Type::Enum v) const { return v == Type::IfcCartesianTransformationOperator2D || IfcCartesianTransformationOperator::is(v); } -Type::Enum IfcCartesianTransformationOperator2D::type() const { return Type::IfcCartesianTransformationOperator2D; } + + +const IfcParse::entity& IfcCartesianTransformationOperator2D::declaration() const { return *IfcCartesianTransformationOperator2D_type; } Type::Enum IfcCartesianTransformationOperator2D::Class() { return Type::IfcCartesianTransformationOperator2D; } -IfcCartesianTransformationOperator2D::IfcCartesianTransformationOperator2D(IfcAbstractEntity* e) : IfcCartesianTransformationOperator((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianTransformationOperator2D)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCartesianTransformationOperator2D::IfcCartesianTransformationOperator2D(IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale) : IfcCartesianTransformationOperator((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Axis1)); e->setArgument(1,(v2_Axis2)); e->setArgument(2,(v3_LocalOrigin)); if (v4_Scale) { e->setArgument(3,(*v4_Scale)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcCartesianTransformationOperator2D::IfcCartesianTransformationOperator2D(IfcAbstractEntity* e) : IfcCartesianTransformationOperator((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianTransformationOperator2D)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCartesianTransformationOperator2D::IfcCartesianTransformationOperator2D(IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale) : IfcCartesianTransformationOperator((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Axis1)); e->setArgument(1,(v2_Axis2)); e->setArgument(2,(v3_LocalOrigin)); if (v4_Scale) { e->setArgument(3,(*v4_Scale)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCartesianTransformationOperator2DnonUniform -bool IfcCartesianTransformationOperator2DnonUniform::hasScale2() const { return !entity->getArgument(4)->isNull(); } -double IfcCartesianTransformationOperator2DnonUniform::Scale2() const { return *entity->getArgument(4); } -void IfcCartesianTransformationOperator2DnonUniform::setScale2(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcCartesianTransformationOperator2DnonUniform::is(Type::Enum v) const { return v == Type::IfcCartesianTransformationOperator2DnonUniform || IfcCartesianTransformationOperator2D::is(v); } -Type::Enum IfcCartesianTransformationOperator2DnonUniform::type() const { return Type::IfcCartesianTransformationOperator2DnonUniform; } +bool IfcCartesianTransformationOperator2DnonUniform::hasScale2() const { return !data_->getArgument(4)->isNull(); } +double IfcCartesianTransformationOperator2DnonUniform::Scale2() const { return *data_->getArgument(4); } +void IfcCartesianTransformationOperator2DnonUniform::setScale2(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcCartesianTransformationOperator2DnonUniform::declaration() const { return *IfcCartesianTransformationOperator2DnonUniform_type; } Type::Enum IfcCartesianTransformationOperator2DnonUniform::Class() { return Type::IfcCartesianTransformationOperator2DnonUniform; } -IfcCartesianTransformationOperator2DnonUniform::IfcCartesianTransformationOperator2DnonUniform(IfcAbstractEntity* e) : IfcCartesianTransformationOperator2D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianTransformationOperator2DnonUniform)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCartesianTransformationOperator2DnonUniform::IfcCartesianTransformationOperator2DnonUniform(IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, boost::optional< double > v5_Scale2) : IfcCartesianTransformationOperator2D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Axis1)); e->setArgument(1,(v2_Axis2)); e->setArgument(2,(v3_LocalOrigin)); if (v4_Scale) { e->setArgument(3,(*v4_Scale)); } else { e->setArgument(3); } if (v5_Scale2) { e->setArgument(4,(*v5_Scale2)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcCartesianTransformationOperator2DnonUniform::IfcCartesianTransformationOperator2DnonUniform(IfcAbstractEntity* e) : IfcCartesianTransformationOperator2D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianTransformationOperator2DnonUniform)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCartesianTransformationOperator2DnonUniform::IfcCartesianTransformationOperator2DnonUniform(IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, boost::optional< double > v5_Scale2) : IfcCartesianTransformationOperator2D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Axis1)); e->setArgument(1,(v2_Axis2)); e->setArgument(2,(v3_LocalOrigin)); if (v4_Scale) { e->setArgument(3,(*v4_Scale)); } else { e->setArgument(3); } if (v5_Scale2) { e->setArgument(4,(*v5_Scale2)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCartesianTransformationOperator3D -bool IfcCartesianTransformationOperator3D::hasAxis3() const { return !entity->getArgument(4)->isNull(); } -IfcDirection* IfcCartesianTransformationOperator3D::Axis3() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcCartesianTransformationOperator3D::setAxis3(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcCartesianTransformationOperator3D::is(Type::Enum v) const { return v == Type::IfcCartesianTransformationOperator3D || IfcCartesianTransformationOperator::is(v); } -Type::Enum IfcCartesianTransformationOperator3D::type() const { return Type::IfcCartesianTransformationOperator3D; } +bool IfcCartesianTransformationOperator3D::hasAxis3() const { return !data_->getArgument(4)->isNull(); } +IfcDirection* IfcCartesianTransformationOperator3D::Axis3() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcCartesianTransformationOperator3D::setAxis3(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcCartesianTransformationOperator3D::declaration() const { return *IfcCartesianTransformationOperator3D_type; } Type::Enum IfcCartesianTransformationOperator3D::Class() { return Type::IfcCartesianTransformationOperator3D; } -IfcCartesianTransformationOperator3D::IfcCartesianTransformationOperator3D(IfcAbstractEntity* e) : IfcCartesianTransformationOperator((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianTransformationOperator3D)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCartesianTransformationOperator3D::IfcCartesianTransformationOperator3D(IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, IfcDirection* v5_Axis3) : IfcCartesianTransformationOperator((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Axis1)); e->setArgument(1,(v2_Axis2)); e->setArgument(2,(v3_LocalOrigin)); if (v4_Scale) { e->setArgument(3,(*v4_Scale)); } else { e->setArgument(3); } e->setArgument(4,(v5_Axis3)); entity = e; EntityBuffer::Add(this); } +IfcCartesianTransformationOperator3D::IfcCartesianTransformationOperator3D(IfcAbstractEntity* e) : IfcCartesianTransformationOperator((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianTransformationOperator3D)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCartesianTransformationOperator3D::IfcCartesianTransformationOperator3D(IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, IfcDirection* v5_Axis3) : IfcCartesianTransformationOperator((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Axis1)); e->setArgument(1,(v2_Axis2)); e->setArgument(2,(v3_LocalOrigin)); if (v4_Scale) { e->setArgument(3,(*v4_Scale)); } else { e->setArgument(3); } e->setArgument(4,(v5_Axis3)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCartesianTransformationOperator3DnonUniform -bool IfcCartesianTransformationOperator3DnonUniform::hasScale2() const { return !entity->getArgument(5)->isNull(); } -double IfcCartesianTransformationOperator3DnonUniform::Scale2() const { return *entity->getArgument(5); } -void IfcCartesianTransformationOperator3DnonUniform::setScale2(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcCartesianTransformationOperator3DnonUniform::hasScale3() const { return !entity->getArgument(6)->isNull(); } -double IfcCartesianTransformationOperator3DnonUniform::Scale3() const { return *entity->getArgument(6); } -void IfcCartesianTransformationOperator3DnonUniform::setScale3(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcCartesianTransformationOperator3DnonUniform::is(Type::Enum v) const { return v == Type::IfcCartesianTransformationOperator3DnonUniform || IfcCartesianTransformationOperator3D::is(v); } -Type::Enum IfcCartesianTransformationOperator3DnonUniform::type() const { return Type::IfcCartesianTransformationOperator3DnonUniform; } +bool IfcCartesianTransformationOperator3DnonUniform::hasScale2() const { return !data_->getArgument(5)->isNull(); } +double IfcCartesianTransformationOperator3DnonUniform::Scale2() const { return *data_->getArgument(5); } +void IfcCartesianTransformationOperator3DnonUniform::setScale2(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcCartesianTransformationOperator3DnonUniform::hasScale3() const { return !data_->getArgument(6)->isNull(); } +double IfcCartesianTransformationOperator3DnonUniform::Scale3() const { return *data_->getArgument(6); } +void IfcCartesianTransformationOperator3DnonUniform::setScale3(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcCartesianTransformationOperator3DnonUniform::declaration() const { return *IfcCartesianTransformationOperator3DnonUniform_type; } Type::Enum IfcCartesianTransformationOperator3DnonUniform::Class() { return Type::IfcCartesianTransformationOperator3DnonUniform; } -IfcCartesianTransformationOperator3DnonUniform::IfcCartesianTransformationOperator3DnonUniform(IfcAbstractEntity* e) : IfcCartesianTransformationOperator3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianTransformationOperator3DnonUniform)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCartesianTransformationOperator3DnonUniform::IfcCartesianTransformationOperator3DnonUniform(IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, IfcDirection* v5_Axis3, boost::optional< double > v6_Scale2, boost::optional< double > v7_Scale3) : IfcCartesianTransformationOperator3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Axis1)); e->setArgument(1,(v2_Axis2)); e->setArgument(2,(v3_LocalOrigin)); if (v4_Scale) { e->setArgument(3,(*v4_Scale)); } else { e->setArgument(3); } e->setArgument(4,(v5_Axis3)); if (v6_Scale2) { e->setArgument(5,(*v6_Scale2)); } else { e->setArgument(5); } if (v7_Scale3) { e->setArgument(6,(*v7_Scale3)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcCartesianTransformationOperator3DnonUniform::IfcCartesianTransformationOperator3DnonUniform(IfcAbstractEntity* e) : IfcCartesianTransformationOperator3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianTransformationOperator3DnonUniform)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCartesianTransformationOperator3DnonUniform::IfcCartesianTransformationOperator3DnonUniform(IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, IfcDirection* v5_Axis3, boost::optional< double > v6_Scale2, boost::optional< double > v7_Scale3) : IfcCartesianTransformationOperator3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Axis1)); e->setArgument(1,(v2_Axis2)); e->setArgument(2,(v3_LocalOrigin)); if (v4_Scale) { e->setArgument(3,(*v4_Scale)); } else { e->setArgument(3); } e->setArgument(4,(v5_Axis3)); if (v6_Scale2) { e->setArgument(5,(*v6_Scale2)); } else { e->setArgument(5); } if (v7_Scale3) { e->setArgument(6,(*v7_Scale3)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCenterLineProfileDef -double IfcCenterLineProfileDef::Thickness() const { return *entity->getArgument(3); } -void IfcCenterLineProfileDef::setThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcCenterLineProfileDef::is(Type::Enum v) const { return v == Type::IfcCenterLineProfileDef || IfcArbitraryOpenProfileDef::is(v); } -Type::Enum IfcCenterLineProfileDef::type() const { return Type::IfcCenterLineProfileDef; } +double IfcCenterLineProfileDef::Thickness() const { return *data_->getArgument(3); } +void IfcCenterLineProfileDef::setThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcCenterLineProfileDef::declaration() const { return *IfcCenterLineProfileDef_type; } Type::Enum IfcCenterLineProfileDef::Class() { return Type::IfcCenterLineProfileDef; } -IfcCenterLineProfileDef::IfcCenterLineProfileDef(IfcAbstractEntity* e) : IfcArbitraryOpenProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCenterLineProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCenterLineProfileDef::IfcCenterLineProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcBoundedCurve* v3_Curve, double v4_Thickness) : IfcArbitraryOpenProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Curve)); e->setArgument(3,(v4_Thickness)); entity = e; EntityBuffer::Add(this); } +IfcCenterLineProfileDef::IfcCenterLineProfileDef(IfcAbstractEntity* e) : IfcArbitraryOpenProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCenterLineProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCenterLineProfileDef::IfcCenterLineProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcBoundedCurve* v3_Curve, double v4_Thickness) : IfcArbitraryOpenProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Curve)); e->setArgument(3,(v4_Thickness)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcChamferEdgeFeature -bool IfcChamferEdgeFeature::hasWidth() const { return !entity->getArgument(9)->isNull(); } -double IfcChamferEdgeFeature::Width() const { return *entity->getArgument(9); } -void IfcChamferEdgeFeature::setWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcChamferEdgeFeature::hasHeight() const { return !entity->getArgument(10)->isNull(); } -double IfcChamferEdgeFeature::Height() const { return *entity->getArgument(10); } -void IfcChamferEdgeFeature::setHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcChamferEdgeFeature::is(Type::Enum v) const { return v == Type::IfcChamferEdgeFeature || IfcEdgeFeature::is(v); } -Type::Enum IfcChamferEdgeFeature::type() const { return Type::IfcChamferEdgeFeature; } +bool IfcChamferEdgeFeature::hasWidth() const { return !data_->getArgument(9)->isNull(); } +double IfcChamferEdgeFeature::Width() const { return *data_->getArgument(9); } +void IfcChamferEdgeFeature::setWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcChamferEdgeFeature::hasHeight() const { return !data_->getArgument(10)->isNull(); } +double IfcChamferEdgeFeature::Height() const { return *data_->getArgument(10); } +void IfcChamferEdgeFeature::setHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcChamferEdgeFeature::declaration() const { return *IfcChamferEdgeFeature_type; } Type::Enum IfcChamferEdgeFeature::Class() { return Type::IfcChamferEdgeFeature; } -IfcChamferEdgeFeature::IfcChamferEdgeFeature(IfcAbstractEntity* e) : IfcEdgeFeature((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcChamferEdgeFeature)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcChamferEdgeFeature::IfcChamferEdgeFeature(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength, boost::optional< double > v10_Width, boost::optional< double > v11_Height) : IfcEdgeFeature((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_FeatureLength) { e->setArgument(8,(*v9_FeatureLength)); } else { e->setArgument(8); } if (v10_Width) { e->setArgument(9,(*v10_Width)); } else { e->setArgument(9); } if (v11_Height) { e->setArgument(10,(*v11_Height)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcChamferEdgeFeature::IfcChamferEdgeFeature(IfcAbstractEntity* e) : IfcEdgeFeature((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcChamferEdgeFeature)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcChamferEdgeFeature::IfcChamferEdgeFeature(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength, boost::optional< double > v10_Width, boost::optional< double > v11_Height) : IfcEdgeFeature((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_FeatureLength) { e->setArgument(8,(*v9_FeatureLength)); } else { e->setArgument(8); } if (v10_Width) { e->setArgument(9,(*v10_Width)); } else { e->setArgument(9); } if (v11_Height) { e->setArgument(10,(*v11_Height)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcChillerType -IfcChillerTypeEnum::IfcChillerTypeEnum IfcChillerType::PredefinedType() const { return IfcChillerTypeEnum::FromString(*entity->getArgument(9)); } -void IfcChillerType::setPredefinedType(IfcChillerTypeEnum::IfcChillerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcChillerTypeEnum::ToString(v)); } -bool IfcChillerType::is(Type::Enum v) const { return v == Type::IfcChillerType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcChillerType::type() const { return Type::IfcChillerType; } +IfcChillerTypeEnum::IfcChillerTypeEnum IfcChillerType::PredefinedType() const { return IfcChillerTypeEnum::FromString(*data_->getArgument(9)); } +void IfcChillerType::setPredefinedType(IfcChillerTypeEnum::IfcChillerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcChillerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcChillerType::declaration() const { return *IfcChillerType_type; } Type::Enum IfcChillerType::Class() { return Type::IfcChillerType; } -IfcChillerType::IfcChillerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcChillerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcChillerType::IfcChillerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcChillerTypeEnum::IfcChillerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcChillerTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcChillerType::IfcChillerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcChillerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcChillerType::IfcChillerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcChillerTypeEnum::IfcChillerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcChillerTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCircle -double IfcCircle::Radius() const { return *entity->getArgument(1); } -void IfcCircle::setRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcCircle::is(Type::Enum v) const { return v == Type::IfcCircle || IfcConic::is(v); } -Type::Enum IfcCircle::type() const { return Type::IfcCircle; } +double IfcCircle::Radius() const { return *data_->getArgument(1); } +void IfcCircle::setRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcCircle::declaration() const { return *IfcCircle_type; } Type::Enum IfcCircle::Class() { return Type::IfcCircle; } -IfcCircle::IfcCircle(IfcAbstractEntity* e) : IfcConic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCircle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCircle::IfcCircle(IfcAxis2Placement* v1_Position, double v2_Radius) : IfcConic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_Radius)); entity = e; EntityBuffer::Add(this); } +IfcCircle::IfcCircle(IfcAbstractEntity* e) : IfcConic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCircle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCircle::IfcCircle(IfcAxis2Placement* v1_Position, double v2_Radius) : IfcConic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_Radius)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCircleHollowProfileDef -double IfcCircleHollowProfileDef::WallThickness() const { return *entity->getArgument(4); } -void IfcCircleHollowProfileDef::setWallThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcCircleHollowProfileDef::is(Type::Enum v) const { return v == Type::IfcCircleHollowProfileDef || IfcCircleProfileDef::is(v); } -Type::Enum IfcCircleHollowProfileDef::type() const { return Type::IfcCircleHollowProfileDef; } +double IfcCircleHollowProfileDef::WallThickness() const { return *data_->getArgument(4); } +void IfcCircleHollowProfileDef::setWallThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcCircleHollowProfileDef::declaration() const { return *IfcCircleHollowProfileDef_type; } Type::Enum IfcCircleHollowProfileDef::Class() { return Type::IfcCircleHollowProfileDef; } -IfcCircleHollowProfileDef::IfcCircleHollowProfileDef(IfcAbstractEntity* e) : IfcCircleProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCircleHollowProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCircleHollowProfileDef::IfcCircleHollowProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Radius, double v5_WallThickness) : IfcCircleProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Radius)); e->setArgument(4,(v5_WallThickness)); entity = e; EntityBuffer::Add(this); } +IfcCircleHollowProfileDef::IfcCircleHollowProfileDef(IfcAbstractEntity* e) : IfcCircleProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCircleHollowProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCircleHollowProfileDef::IfcCircleHollowProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Radius, double v5_WallThickness) : IfcCircleProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Radius)); e->setArgument(4,(v5_WallThickness)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCircleProfileDef -double IfcCircleProfileDef::Radius() const { return *entity->getArgument(3); } -void IfcCircleProfileDef::setRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcCircleProfileDef::is(Type::Enum v) const { return v == Type::IfcCircleProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcCircleProfileDef::type() const { return Type::IfcCircleProfileDef; } +double IfcCircleProfileDef::Radius() const { return *data_->getArgument(3); } +void IfcCircleProfileDef::setRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcCircleProfileDef::declaration() const { return *IfcCircleProfileDef_type; } Type::Enum IfcCircleProfileDef::Class() { return Type::IfcCircleProfileDef; } -IfcCircleProfileDef::IfcCircleProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCircleProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCircleProfileDef::IfcCircleProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Radius) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Radius)); entity = e; EntityBuffer::Add(this); } +IfcCircleProfileDef::IfcCircleProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCircleProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCircleProfileDef::IfcCircleProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Radius) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Radius)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcClassification -std::string IfcClassification::Source() const { return *entity->getArgument(0); } -void IfcClassification::setSource(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -std::string IfcClassification::Edition() const { return *entity->getArgument(1); } -void IfcClassification::setEdition(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcClassification::hasEditionDate() const { return !entity->getArgument(2)->isNull(); } -IfcCalendarDate* IfcClassification::EditionDate() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcClassification::setEditionDate(IfcCalendarDate* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -std::string IfcClassification::Name() const { return *entity->getArgument(3); } -void IfcClassification::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -IfcClassificationItem::list::ptr IfcClassification::Contains() const { return entity->getInverse(Type::IfcClassificationItem, 1)->as(); } -bool IfcClassification::is(Type::Enum v) const { return v == Type::IfcClassification; } -Type::Enum IfcClassification::type() const { return Type::IfcClassification; } +std::string IfcClassification::Source() const { return *data_->getArgument(0); } +void IfcClassification::setSource(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +std::string IfcClassification::Edition() const { return *data_->getArgument(1); } +void IfcClassification::setEdition(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcClassification::hasEditionDate() const { return !data_->getArgument(2)->isNull(); } +IfcCalendarDate* IfcClassification::EditionDate() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcClassification::setEditionDate(IfcCalendarDate* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +std::string IfcClassification::Name() const { return *data_->getArgument(3); } +void IfcClassification::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + +IfcClassificationItem::list::ptr IfcClassification::Contains() const { return data_->getInverse(Type::IfcClassificationItem, 1)->as(); } + +const IfcParse::entity& IfcClassification::declaration() const { return *IfcClassification_type; } Type::Enum IfcClassification::Class() { return Type::IfcClassification; } -IfcClassification::IfcClassification(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcClassification)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcClassification::IfcClassification(std::string v1_Source, std::string v2_Edition, IfcCalendarDate* v3_EditionDate, std::string v4_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Source)); e->setArgument(1,(v2_Edition)); e->setArgument(2,(v3_EditionDate)); e->setArgument(3,(v4_Name)); entity = e; EntityBuffer::Add(this); } +IfcClassification::IfcClassification(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcClassification)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcClassification::IfcClassification(std::string v1_Source, std::string v2_Edition, IfcCalendarDate* v3_EditionDate, std::string v4_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Source)); e->setArgument(1,(v2_Edition)); e->setArgument(2,(v3_EditionDate)); e->setArgument(3,(v4_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcClassificationItem -IfcClassificationNotationFacet* IfcClassificationItem::Notation() const { return (IfcClassificationNotationFacet*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcClassificationItem::setNotation(IfcClassificationNotationFacet* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcClassificationItem::hasItemOf() const { return !entity->getArgument(1)->isNull(); } -IfcClassification* IfcClassificationItem::ItemOf() const { return (IfcClassification*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcClassificationItem::setItemOf(IfcClassification* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -std::string IfcClassificationItem::Title() const { return *entity->getArgument(2); } -void IfcClassificationItem::setTitle(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcClassificationItemRelationship::list::ptr IfcClassificationItem::IsClassifiedItemIn() const { return entity->getInverse(Type::IfcClassificationItemRelationship, 1)->as(); } -IfcClassificationItemRelationship::list::ptr IfcClassificationItem::IsClassifyingItemIn() const { return entity->getInverse(Type::IfcClassificationItemRelationship, 0)->as(); } -bool IfcClassificationItem::is(Type::Enum v) const { return v == Type::IfcClassificationItem; } -Type::Enum IfcClassificationItem::type() const { return Type::IfcClassificationItem; } +IfcClassificationNotationFacet* IfcClassificationItem::Notation() const { return (IfcClassificationNotationFacet*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcClassificationItem::setNotation(IfcClassificationNotationFacet* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcClassificationItem::hasItemOf() const { return !data_->getArgument(1)->isNull(); } +IfcClassification* IfcClassificationItem::ItemOf() const { return (IfcClassification*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcClassificationItem::setItemOf(IfcClassification* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +std::string IfcClassificationItem::Title() const { return *data_->getArgument(2); } +void IfcClassificationItem::setTitle(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + +IfcClassificationItemRelationship::list::ptr IfcClassificationItem::IsClassifiedItemIn() const { return data_->getInverse(Type::IfcClassificationItemRelationship, 1)->as(); } +IfcClassificationItemRelationship::list::ptr IfcClassificationItem::IsClassifyingItemIn() const { return data_->getInverse(Type::IfcClassificationItemRelationship, 0)->as(); } + +const IfcParse::entity& IfcClassificationItem::declaration() const { return *IfcClassificationItem_type; } Type::Enum IfcClassificationItem::Class() { return Type::IfcClassificationItem; } -IfcClassificationItem::IfcClassificationItem(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcClassificationItem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcClassificationItem::IfcClassificationItem(IfcClassificationNotationFacet* v1_Notation, IfcClassification* v2_ItemOf, std::string v3_Title) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Notation)); e->setArgument(1,(v2_ItemOf)); e->setArgument(2,(v3_Title)); entity = e; EntityBuffer::Add(this); } +IfcClassificationItem::IfcClassificationItem(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcClassificationItem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcClassificationItem::IfcClassificationItem(IfcClassificationNotationFacet* v1_Notation, IfcClassification* v2_ItemOf, std::string v3_Title) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Notation)); e->setArgument(1,(v2_ItemOf)); e->setArgument(2,(v3_Title)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcClassificationItemRelationship -IfcClassificationItem* IfcClassificationItemRelationship::RelatingItem() const { return (IfcClassificationItem*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcClassificationItemRelationship::setRelatingItem(IfcClassificationItem* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcTemplatedEntityList< IfcClassificationItem >::ptr IfcClassificationItemRelationship::RelatedItems() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcClassificationItemRelationship::setRelatedItems(IfcTemplatedEntityList< IfcClassificationItem >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcClassificationItemRelationship::is(Type::Enum v) const { return v == Type::IfcClassificationItemRelationship; } -Type::Enum IfcClassificationItemRelationship::type() const { return Type::IfcClassificationItemRelationship; } +IfcClassificationItem* IfcClassificationItemRelationship::RelatingItem() const { return (IfcClassificationItem*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcClassificationItemRelationship::setRelatingItem(IfcClassificationItem* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcTemplatedEntityList< IfcClassificationItem >::ptr IfcClassificationItemRelationship::RelatedItems() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcClassificationItemRelationship::setRelatedItems(IfcTemplatedEntityList< IfcClassificationItem >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } + + +const IfcParse::entity& IfcClassificationItemRelationship::declaration() const { return *IfcClassificationItemRelationship_type; } Type::Enum IfcClassificationItemRelationship::Class() { return Type::IfcClassificationItemRelationship; } -IfcClassificationItemRelationship::IfcClassificationItemRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcClassificationItemRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcClassificationItemRelationship::IfcClassificationItemRelationship(IfcClassificationItem* v1_RelatingItem, IfcTemplatedEntityList< IfcClassificationItem >::ptr v2_RelatedItems) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelatingItem)); e->setArgument(1,(v2_RelatedItems)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcClassificationItemRelationship::IfcClassificationItemRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcClassificationItemRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcClassificationItemRelationship::IfcClassificationItemRelationship(IfcClassificationItem* v1_RelatingItem, IfcTemplatedEntityList< IfcClassificationItem >::ptr v2_RelatedItems) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelatingItem)); e->setArgument(1,(v2_RelatedItems)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcClassificationNotation -IfcTemplatedEntityList< IfcClassificationNotationFacet >::ptr IfcClassificationNotation::NotationFacets() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcClassificationNotation::setNotationFacets(IfcTemplatedEntityList< IfcClassificationNotationFacet >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcClassificationNotation::is(Type::Enum v) const { return v == Type::IfcClassificationNotation; } -Type::Enum IfcClassificationNotation::type() const { return Type::IfcClassificationNotation; } +IfcTemplatedEntityList< IfcClassificationNotationFacet >::ptr IfcClassificationNotation::NotationFacets() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcClassificationNotation::setNotationFacets(IfcTemplatedEntityList< IfcClassificationNotationFacet >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcClassificationNotation::declaration() const { return *IfcClassificationNotation_type; } Type::Enum IfcClassificationNotation::Class() { return Type::IfcClassificationNotation; } -IfcClassificationNotation::IfcClassificationNotation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcClassificationNotation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcClassificationNotation::IfcClassificationNotation(IfcTemplatedEntityList< IfcClassificationNotationFacet >::ptr v1_NotationFacets) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_NotationFacets)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcClassificationNotation::IfcClassificationNotation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcClassificationNotation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcClassificationNotation::IfcClassificationNotation(IfcTemplatedEntityList< IfcClassificationNotationFacet >::ptr v1_NotationFacets) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_NotationFacets)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcClassificationNotationFacet -std::string IfcClassificationNotationFacet::NotationValue() const { return *entity->getArgument(0); } -void IfcClassificationNotationFacet::setNotationValue(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcClassificationNotationFacet::is(Type::Enum v) const { return v == Type::IfcClassificationNotationFacet; } -Type::Enum IfcClassificationNotationFacet::type() const { return Type::IfcClassificationNotationFacet; } +std::string IfcClassificationNotationFacet::NotationValue() const { return *data_->getArgument(0); } +void IfcClassificationNotationFacet::setNotationValue(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcClassificationNotationFacet::declaration() const { return *IfcClassificationNotationFacet_type; } Type::Enum IfcClassificationNotationFacet::Class() { return Type::IfcClassificationNotationFacet; } -IfcClassificationNotationFacet::IfcClassificationNotationFacet(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcClassificationNotationFacet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcClassificationNotationFacet::IfcClassificationNotationFacet(std::string v1_NotationValue) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_NotationValue)); entity = e; EntityBuffer::Add(this); } +IfcClassificationNotationFacet::IfcClassificationNotationFacet(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcClassificationNotationFacet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcClassificationNotationFacet::IfcClassificationNotationFacet(std::string v1_NotationValue) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_NotationValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcClassificationReference -bool IfcClassificationReference::hasReferencedSource() const { return !entity->getArgument(3)->isNull(); } -IfcClassification* IfcClassificationReference::ReferencedSource() const { return (IfcClassification*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcClassificationReference::setReferencedSource(IfcClassification* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcClassificationReference::is(Type::Enum v) const { return v == Type::IfcClassificationReference || IfcExternalReference::is(v); } -Type::Enum IfcClassificationReference::type() const { return Type::IfcClassificationReference; } +bool IfcClassificationReference::hasReferencedSource() const { return !data_->getArgument(3)->isNull(); } +IfcClassification* IfcClassificationReference::ReferencedSource() const { return (IfcClassification*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcClassificationReference::setReferencedSource(IfcClassification* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcClassificationReference::declaration() const { return *IfcClassificationReference_type; } Type::Enum IfcClassificationReference::Class() { return Type::IfcClassificationReference; } -IfcClassificationReference::IfcClassificationReference(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcClassificationReference)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcClassificationReference::IfcClassificationReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name, IfcClassification* v4_ReferencedSource) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } e->setArgument(3,(v4_ReferencedSource)); entity = e; EntityBuffer::Add(this); } +IfcClassificationReference::IfcClassificationReference(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcClassificationReference)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcClassificationReference::IfcClassificationReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name, IfcClassification* v4_ReferencedSource) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } e->setArgument(3,(v4_ReferencedSource)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcClosedShell -bool IfcClosedShell::is(Type::Enum v) const { return v == Type::IfcClosedShell || IfcConnectedFaceSet::is(v); } -Type::Enum IfcClosedShell::type() const { return Type::IfcClosedShell; } + + +const IfcParse::entity& IfcClosedShell::declaration() const { return *IfcClosedShell_type; } Type::Enum IfcClosedShell::Class() { return Type::IfcClosedShell; } -IfcClosedShell::IfcClosedShell(IfcAbstractEntity* e) : IfcConnectedFaceSet((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcClosedShell)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcClosedShell::IfcClosedShell(IfcTemplatedEntityList< IfcFace >::ptr v1_CfsFaces) : IfcConnectedFaceSet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_CfsFaces)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcClosedShell::IfcClosedShell(IfcAbstractEntity* e) : IfcConnectedFaceSet((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcClosedShell)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcClosedShell::IfcClosedShell(IfcTemplatedEntityList< IfcFace >::ptr v1_CfsFaces) : IfcConnectedFaceSet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_CfsFaces)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCoilType -IfcCoilTypeEnum::IfcCoilTypeEnum IfcCoilType::PredefinedType() const { return IfcCoilTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCoilType::setPredefinedType(IfcCoilTypeEnum::IfcCoilTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCoilTypeEnum::ToString(v)); } -bool IfcCoilType::is(Type::Enum v) const { return v == Type::IfcCoilType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcCoilType::type() const { return Type::IfcCoilType; } +IfcCoilTypeEnum::IfcCoilTypeEnum IfcCoilType::PredefinedType() const { return IfcCoilTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCoilType::setPredefinedType(IfcCoilTypeEnum::IfcCoilTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCoilTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCoilType::declaration() const { return *IfcCoilType_type; } Type::Enum IfcCoilType::Class() { return Type::IfcCoilType; } -IfcCoilType::IfcCoilType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCoilType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCoilType::IfcCoilType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCoilTypeEnum::IfcCoilTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCoilTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCoilType::IfcCoilType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCoilType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCoilType::IfcCoilType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCoilTypeEnum::IfcCoilTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCoilTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcColourRgb -double IfcColourRgb::Red() const { return *entity->getArgument(1); } -void IfcColourRgb::setRed(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcColourRgb::Green() const { return *entity->getArgument(2); } -void IfcColourRgb::setGreen(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -double IfcColourRgb::Blue() const { return *entity->getArgument(3); } -void IfcColourRgb::setBlue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcColourRgb::is(Type::Enum v) const { return v == Type::IfcColourRgb || IfcColourSpecification::is(v); } -Type::Enum IfcColourRgb::type() const { return Type::IfcColourRgb; } +double IfcColourRgb::Red() const { return *data_->getArgument(1); } +void IfcColourRgb::setRed(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcColourRgb::Green() const { return *data_->getArgument(2); } +void IfcColourRgb::setGreen(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +double IfcColourRgb::Blue() const { return *data_->getArgument(3); } +void IfcColourRgb::setBlue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcColourRgb::declaration() const { return *IfcColourRgb_type; } Type::Enum IfcColourRgb::Class() { return Type::IfcColourRgb; } -IfcColourRgb::IfcColourRgb(IfcAbstractEntity* e) : IfcColourSpecification((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcColourRgb)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcColourRgb::IfcColourRgb(boost::optional< std::string > v1_Name, double v2_Red, double v3_Green, double v4_Blue) : IfcColourSpecification((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_Red)); e->setArgument(2,(v3_Green)); e->setArgument(3,(v4_Blue)); entity = e; EntityBuffer::Add(this); } +IfcColourRgb::IfcColourRgb(IfcAbstractEntity* e) : IfcColourSpecification((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcColourRgb)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcColourRgb::IfcColourRgb(boost::optional< std::string > v1_Name, double v2_Red, double v3_Green, double v4_Blue) : IfcColourSpecification((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_Red)); e->setArgument(2,(v3_Green)); e->setArgument(3,(v4_Blue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcColourSpecification -bool IfcColourSpecification::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcColourSpecification::Name() const { return *entity->getArgument(0); } -void IfcColourSpecification::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcColourSpecification::is(Type::Enum v) const { return v == Type::IfcColourSpecification; } -Type::Enum IfcColourSpecification::type() const { return Type::IfcColourSpecification; } +bool IfcColourSpecification::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcColourSpecification::Name() const { return *data_->getArgument(0); } +void IfcColourSpecification::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcColourSpecification::declaration() const { return *IfcColourSpecification_type; } Type::Enum IfcColourSpecification::Class() { return Type::IfcColourSpecification; } -IfcColourSpecification::IfcColourSpecification(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcColourSpecification)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcColourSpecification::IfcColourSpecification(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } entity = e; EntityBuffer::Add(this); } +IfcColourSpecification::IfcColourSpecification(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcColourSpecification)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcColourSpecification::IfcColourSpecification(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcColumn -bool IfcColumn::is(Type::Enum v) const { return v == Type::IfcColumn || IfcBuildingElement::is(v); } -Type::Enum IfcColumn::type() const { return Type::IfcColumn; } + + +const IfcParse::entity& IfcColumn::declaration() const { return *IfcColumn_type; } Type::Enum IfcColumn::Class() { return Type::IfcColumn; } -IfcColumn::IfcColumn(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcColumn)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcColumn::IfcColumn(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcColumn::IfcColumn(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcColumn)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcColumn::IfcColumn(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcColumnType -IfcColumnTypeEnum::IfcColumnTypeEnum IfcColumnType::PredefinedType() const { return IfcColumnTypeEnum::FromString(*entity->getArgument(9)); } -void IfcColumnType::setPredefinedType(IfcColumnTypeEnum::IfcColumnTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcColumnTypeEnum::ToString(v)); } -bool IfcColumnType::is(Type::Enum v) const { return v == Type::IfcColumnType || IfcBuildingElementType::is(v); } -Type::Enum IfcColumnType::type() const { return Type::IfcColumnType; } +IfcColumnTypeEnum::IfcColumnTypeEnum IfcColumnType::PredefinedType() const { return IfcColumnTypeEnum::FromString(*data_->getArgument(9)); } +void IfcColumnType::setPredefinedType(IfcColumnTypeEnum::IfcColumnTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcColumnTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcColumnType::declaration() const { return *IfcColumnType_type; } Type::Enum IfcColumnType::Class() { return Type::IfcColumnType; } -IfcColumnType::IfcColumnType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcColumnType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcColumnType::IfcColumnType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcColumnTypeEnum::IfcColumnTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcColumnTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcColumnType::IfcColumnType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcColumnType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcColumnType::IfcColumnType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcColumnTypeEnum::IfcColumnTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcColumnTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcComplexProperty -std::string IfcComplexProperty::UsageName() const { return *entity->getArgument(2); } -void IfcComplexProperty::setUsageName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcTemplatedEntityList< IfcProperty >::ptr IfcComplexProperty::HasProperties() const { IfcEntityList::ptr es = *entity->getArgument(3); return es->as(); } -void IfcComplexProperty::setHasProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v->generalize()); } -bool IfcComplexProperty::is(Type::Enum v) const { return v == Type::IfcComplexProperty || IfcProperty::is(v); } -Type::Enum IfcComplexProperty::type() const { return Type::IfcComplexProperty; } +std::string IfcComplexProperty::UsageName() const { return *data_->getArgument(2); } +void IfcComplexProperty::setUsageName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcTemplatedEntityList< IfcProperty >::ptr IfcComplexProperty::HasProperties() const { IfcEntityList::ptr es = *data_->getArgument(3); return es->as(); } +void IfcComplexProperty::setHasProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v->generalize()); } + + +const IfcParse::entity& IfcComplexProperty::declaration() const { return *IfcComplexProperty_type; } Type::Enum IfcComplexProperty::Class() { return Type::IfcComplexProperty; } -IfcComplexProperty::IfcComplexProperty(IfcAbstractEntity* e) : IfcProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcComplexProperty)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcComplexProperty::IfcComplexProperty(std::string v1_Name, boost::optional< std::string > v2_Description, std::string v3_UsageName, IfcTemplatedEntityList< IfcProperty >::ptr v4_HasProperties) : IfcProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_UsageName)); e->setArgument(3,(v4_HasProperties)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcComplexProperty::IfcComplexProperty(IfcAbstractEntity* e) : IfcProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcComplexProperty)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcComplexProperty::IfcComplexProperty(std::string v1_Name, boost::optional< std::string > v2_Description, std::string v3_UsageName, IfcTemplatedEntityList< IfcProperty >::ptr v4_HasProperties) : IfcProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_UsageName)); e->setArgument(3,(v4_HasProperties)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCompositeCurve -IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr IfcCompositeCurve::Segments() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcCompositeCurve::setSegments(IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcCompositeCurve::SelfIntersect() const { return *entity->getArgument(1); } -void IfcCompositeCurve::setSelfIntersect(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcCompositeCurve::is(Type::Enum v) const { return v == Type::IfcCompositeCurve || IfcBoundedCurve::is(v); } -Type::Enum IfcCompositeCurve::type() const { return Type::IfcCompositeCurve; } +IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr IfcCompositeCurve::Segments() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcCompositeCurve::setSegments(IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } +bool IfcCompositeCurve::SelfIntersect() const { return *data_->getArgument(1); } +void IfcCompositeCurve::setSelfIntersect(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcCompositeCurve::declaration() const { return *IfcCompositeCurve_type; } Type::Enum IfcCompositeCurve::Class() { return Type::IfcCompositeCurve; } -IfcCompositeCurve::IfcCompositeCurve(IfcAbstractEntity* e) : IfcBoundedCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompositeCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCompositeCurve::IfcCompositeCurve(IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect) : IfcBoundedCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Segments)->generalize()); e->setArgument(1,(v2_SelfIntersect)); entity = e; EntityBuffer::Add(this); } +IfcCompositeCurve::IfcCompositeCurve(IfcAbstractEntity* e) : IfcBoundedCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompositeCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCompositeCurve::IfcCompositeCurve(IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect) : IfcBoundedCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Segments)->generalize()); e->setArgument(1,(v2_SelfIntersect)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCompositeCurveSegment -IfcTransitionCode::IfcTransitionCode IfcCompositeCurveSegment::Transition() const { return IfcTransitionCode::FromString(*entity->getArgument(0)); } -void IfcCompositeCurveSegment::setTransition(IfcTransitionCode::IfcTransitionCode v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v,IfcTransitionCode::ToString(v)); } -bool IfcCompositeCurveSegment::SameSense() const { return *entity->getArgument(1); } -void IfcCompositeCurveSegment::setSameSense(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcCurve* IfcCompositeCurveSegment::ParentCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcCompositeCurveSegment::setParentCurve(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcCompositeCurve::list::ptr IfcCompositeCurveSegment::UsingCurves() const { return entity->getInverse(Type::IfcCompositeCurve, 0)->as(); } -bool IfcCompositeCurveSegment::is(Type::Enum v) const { return v == Type::IfcCompositeCurveSegment || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcCompositeCurveSegment::type() const { return Type::IfcCompositeCurveSegment; } +IfcTransitionCode::IfcTransitionCode IfcCompositeCurveSegment::Transition() const { return IfcTransitionCode::FromString(*data_->getArgument(0)); } +void IfcCompositeCurveSegment::setTransition(IfcTransitionCode::IfcTransitionCode v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v,IfcTransitionCode::ToString(v)); } +bool IfcCompositeCurveSegment::SameSense() const { return *data_->getArgument(1); } +void IfcCompositeCurveSegment::setSameSense(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcCurve* IfcCompositeCurveSegment::ParentCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcCompositeCurveSegment::setParentCurve(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + +IfcCompositeCurve::list::ptr IfcCompositeCurveSegment::UsingCurves() const { return data_->getInverse(Type::IfcCompositeCurve, 0)->as(); } + +const IfcParse::entity& IfcCompositeCurveSegment::declaration() const { return *IfcCompositeCurveSegment_type; } Type::Enum IfcCompositeCurveSegment::Class() { return Type::IfcCompositeCurveSegment; } -IfcCompositeCurveSegment::IfcCompositeCurveSegment(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompositeCurveSegment)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCompositeCurveSegment::IfcCompositeCurveSegment(IfcTransitionCode::IfcTransitionCode v1_Transition, bool v2_SameSense, IfcCurve* v3_ParentCurve) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_Transition,IfcTransitionCode::ToString(v1_Transition)); e->setArgument(1,(v2_SameSense)); e->setArgument(2,(v3_ParentCurve)); entity = e; EntityBuffer::Add(this); } +IfcCompositeCurveSegment::IfcCompositeCurveSegment(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompositeCurveSegment)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCompositeCurveSegment::IfcCompositeCurveSegment(IfcTransitionCode::IfcTransitionCode v1_Transition, bool v2_SameSense, IfcCurve* v3_ParentCurve) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_Transition,IfcTransitionCode::ToString(v1_Transition)); e->setArgument(1,(v2_SameSense)); e->setArgument(2,(v3_ParentCurve)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCompositeProfileDef -IfcTemplatedEntityList< IfcProfileDef >::ptr IfcCompositeProfileDef::Profiles() const { IfcEntityList::ptr es = *entity->getArgument(2); return es->as(); } -void IfcCompositeProfileDef::setProfiles(IfcTemplatedEntityList< IfcProfileDef >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v->generalize()); } -bool IfcCompositeProfileDef::hasLabel() const { return !entity->getArgument(3)->isNull(); } -std::string IfcCompositeProfileDef::Label() const { return *entity->getArgument(3); } -void IfcCompositeProfileDef::setLabel(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcCompositeProfileDef::is(Type::Enum v) const { return v == Type::IfcCompositeProfileDef || IfcProfileDef::is(v); } -Type::Enum IfcCompositeProfileDef::type() const { return Type::IfcCompositeProfileDef; } +IfcTemplatedEntityList< IfcProfileDef >::ptr IfcCompositeProfileDef::Profiles() const { IfcEntityList::ptr es = *data_->getArgument(2); return es->as(); } +void IfcCompositeProfileDef::setProfiles(IfcTemplatedEntityList< IfcProfileDef >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v->generalize()); } +bool IfcCompositeProfileDef::hasLabel() const { return !data_->getArgument(3)->isNull(); } +std::string IfcCompositeProfileDef::Label() const { return *data_->getArgument(3); } +void IfcCompositeProfileDef::setLabel(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcCompositeProfileDef::declaration() const { return *IfcCompositeProfileDef_type; } Type::Enum IfcCompositeProfileDef::Class() { return Type::IfcCompositeProfileDef; } -IfcCompositeProfileDef::IfcCompositeProfileDef(IfcAbstractEntity* e) : IfcProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompositeProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCompositeProfileDef::IfcCompositeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcTemplatedEntityList< IfcProfileDef >::ptr v3_Profiles, boost::optional< std::string > v4_Label) : IfcProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Profiles)->generalize()); if (v4_Label) { e->setArgument(3,(*v4_Label)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcCompositeProfileDef::IfcCompositeProfileDef(IfcAbstractEntity* e) : IfcProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompositeProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCompositeProfileDef::IfcCompositeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcTemplatedEntityList< IfcProfileDef >::ptr v3_Profiles, boost::optional< std::string > v4_Label) : IfcProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Profiles)->generalize()); if (v4_Label) { e->setArgument(3,(*v4_Label)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCompressorType -IfcCompressorTypeEnum::IfcCompressorTypeEnum IfcCompressorType::PredefinedType() const { return IfcCompressorTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCompressorType::setPredefinedType(IfcCompressorTypeEnum::IfcCompressorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCompressorTypeEnum::ToString(v)); } -bool IfcCompressorType::is(Type::Enum v) const { return v == Type::IfcCompressorType || IfcFlowMovingDeviceType::is(v); } -Type::Enum IfcCompressorType::type() const { return Type::IfcCompressorType; } +IfcCompressorTypeEnum::IfcCompressorTypeEnum IfcCompressorType::PredefinedType() const { return IfcCompressorTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCompressorType::setPredefinedType(IfcCompressorTypeEnum::IfcCompressorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCompressorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCompressorType::declaration() const { return *IfcCompressorType_type; } Type::Enum IfcCompressorType::Class() { return Type::IfcCompressorType; } -IfcCompressorType::IfcCompressorType(IfcAbstractEntity* e) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompressorType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCompressorType::IfcCompressorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCompressorTypeEnum::IfcCompressorTypeEnum v10_PredefinedType) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCompressorTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCompressorType::IfcCompressorType(IfcAbstractEntity* e) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompressorType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCompressorType::IfcCompressorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCompressorTypeEnum::IfcCompressorTypeEnum v10_PredefinedType) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCompressorTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCondenserType -IfcCondenserTypeEnum::IfcCondenserTypeEnum IfcCondenserType::PredefinedType() const { return IfcCondenserTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCondenserType::setPredefinedType(IfcCondenserTypeEnum::IfcCondenserTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCondenserTypeEnum::ToString(v)); } -bool IfcCondenserType::is(Type::Enum v) const { return v == Type::IfcCondenserType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcCondenserType::type() const { return Type::IfcCondenserType; } +IfcCondenserTypeEnum::IfcCondenserTypeEnum IfcCondenserType::PredefinedType() const { return IfcCondenserTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCondenserType::setPredefinedType(IfcCondenserTypeEnum::IfcCondenserTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCondenserTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCondenserType::declaration() const { return *IfcCondenserType_type; } Type::Enum IfcCondenserType::Class() { return Type::IfcCondenserType; } -IfcCondenserType::IfcCondenserType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCondenserType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCondenserType::IfcCondenserType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCondenserTypeEnum::IfcCondenserTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCondenserTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCondenserType::IfcCondenserType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCondenserType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCondenserType::IfcCondenserType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCondenserTypeEnum::IfcCondenserTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCondenserTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCondition -bool IfcCondition::is(Type::Enum v) const { return v == Type::IfcCondition || IfcGroup::is(v); } -Type::Enum IfcCondition::type() const { return Type::IfcCondition; } + + +const IfcParse::entity& IfcCondition::declaration() const { return *IfcCondition_type; } Type::Enum IfcCondition::Class() { return Type::IfcCondition; } -IfcCondition::IfcCondition(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCondition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCondition::IfcCondition(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcCondition::IfcCondition(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCondition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCondition::IfcCondition(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConditionCriterion -IfcConditionCriterionSelect* IfcConditionCriterion::Criterion() const { return (IfcConditionCriterionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcConditionCriterion::setCriterion(IfcConditionCriterionSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcDateTimeSelect* IfcConditionCriterion::CriterionDateTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcConditionCriterion::setCriterionDateTime(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcConditionCriterion::is(Type::Enum v) const { return v == Type::IfcConditionCriterion || IfcControl::is(v); } -Type::Enum IfcConditionCriterion::type() const { return Type::IfcConditionCriterion; } +IfcConditionCriterionSelect* IfcConditionCriterion::Criterion() const { return (IfcConditionCriterionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcConditionCriterion::setCriterion(IfcConditionCriterionSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +IfcDateTimeSelect* IfcConditionCriterion::CriterionDateTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcConditionCriterion::setCriterionDateTime(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcConditionCriterion::declaration() const { return *IfcConditionCriterion_type; } Type::Enum IfcConditionCriterion::Class() { return Type::IfcConditionCriterion; } -IfcConditionCriterion::IfcConditionCriterion(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConditionCriterion)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConditionCriterion::IfcConditionCriterion(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcConditionCriterionSelect* v6_Criterion, IfcDateTimeSelect* v7_CriterionDateTime) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_Criterion)); e->setArgument(6,(v7_CriterionDateTime)); entity = e; EntityBuffer::Add(this); } +IfcConditionCriterion::IfcConditionCriterion(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConditionCriterion)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConditionCriterion::IfcConditionCriterion(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcConditionCriterionSelect* v6_Criterion, IfcDateTimeSelect* v7_CriterionDateTime) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_Criterion)); e->setArgument(6,(v7_CriterionDateTime)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConic -IfcAxis2Placement* IfcConic::Position() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcConic::setPosition(IfcAxis2Placement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcConic::is(Type::Enum v) const { return v == Type::IfcConic || IfcCurve::is(v); } -Type::Enum IfcConic::type() const { return Type::IfcConic; } +IfcAxis2Placement* IfcConic::Position() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcConic::setPosition(IfcAxis2Placement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcConic::declaration() const { return *IfcConic_type; } Type::Enum IfcConic::Class() { return Type::IfcConic; } -IfcConic::IfcConic(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConic)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConic::IfcConic(IfcAxis2Placement* v1_Position) : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); entity = e; EntityBuffer::Add(this); } +IfcConic::IfcConic(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConic)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConic::IfcConic(IfcAxis2Placement* v1_Position) : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConnectedFaceSet -IfcTemplatedEntityList< IfcFace >::ptr IfcConnectedFaceSet::CfsFaces() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcConnectedFaceSet::setCfsFaces(IfcTemplatedEntityList< IfcFace >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcConnectedFaceSet::is(Type::Enum v) const { return v == Type::IfcConnectedFaceSet || IfcTopologicalRepresentationItem::is(v); } -Type::Enum IfcConnectedFaceSet::type() const { return Type::IfcConnectedFaceSet; } +IfcTemplatedEntityList< IfcFace >::ptr IfcConnectedFaceSet::CfsFaces() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcConnectedFaceSet::setCfsFaces(IfcTemplatedEntityList< IfcFace >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcConnectedFaceSet::declaration() const { return *IfcConnectedFaceSet_type; } Type::Enum IfcConnectedFaceSet::Class() { return Type::IfcConnectedFaceSet; } -IfcConnectedFaceSet::IfcConnectedFaceSet(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectedFaceSet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConnectedFaceSet::IfcConnectedFaceSet(IfcTemplatedEntityList< IfcFace >::ptr v1_CfsFaces) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_CfsFaces)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcConnectedFaceSet::IfcConnectedFaceSet(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectedFaceSet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConnectedFaceSet::IfcConnectedFaceSet(IfcTemplatedEntityList< IfcFace >::ptr v1_CfsFaces) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_CfsFaces)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConnectionCurveGeometry -IfcCurveOrEdgeCurve* IfcConnectionCurveGeometry::CurveOnRelatingElement() const { return (IfcCurveOrEdgeCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcConnectionCurveGeometry::setCurveOnRelatingElement(IfcCurveOrEdgeCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcConnectionCurveGeometry::hasCurveOnRelatedElement() const { return !entity->getArgument(1)->isNull(); } -IfcCurveOrEdgeCurve* IfcConnectionCurveGeometry::CurveOnRelatedElement() const { return (IfcCurveOrEdgeCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcConnectionCurveGeometry::setCurveOnRelatedElement(IfcCurveOrEdgeCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcConnectionCurveGeometry::is(Type::Enum v) const { return v == Type::IfcConnectionCurveGeometry || IfcConnectionGeometry::is(v); } -Type::Enum IfcConnectionCurveGeometry::type() const { return Type::IfcConnectionCurveGeometry; } +IfcCurveOrEdgeCurve* IfcConnectionCurveGeometry::CurveOnRelatingElement() const { return (IfcCurveOrEdgeCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcConnectionCurveGeometry::setCurveOnRelatingElement(IfcCurveOrEdgeCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcConnectionCurveGeometry::hasCurveOnRelatedElement() const { return !data_->getArgument(1)->isNull(); } +IfcCurveOrEdgeCurve* IfcConnectionCurveGeometry::CurveOnRelatedElement() const { return (IfcCurveOrEdgeCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcConnectionCurveGeometry::setCurveOnRelatedElement(IfcCurveOrEdgeCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcConnectionCurveGeometry::declaration() const { return *IfcConnectionCurveGeometry_type; } Type::Enum IfcConnectionCurveGeometry::Class() { return Type::IfcConnectionCurveGeometry; } -IfcConnectionCurveGeometry::IfcConnectionCurveGeometry(IfcAbstractEntity* e) : IfcConnectionGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionCurveGeometry)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConnectionCurveGeometry::IfcConnectionCurveGeometry(IfcCurveOrEdgeCurve* v1_CurveOnRelatingElement, IfcCurveOrEdgeCurve* v2_CurveOnRelatedElement) : IfcConnectionGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_CurveOnRelatingElement)); e->setArgument(1,(v2_CurveOnRelatedElement)); entity = e; EntityBuffer::Add(this); } +IfcConnectionCurveGeometry::IfcConnectionCurveGeometry(IfcAbstractEntity* e) : IfcConnectionGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionCurveGeometry)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConnectionCurveGeometry::IfcConnectionCurveGeometry(IfcCurveOrEdgeCurve* v1_CurveOnRelatingElement, IfcCurveOrEdgeCurve* v2_CurveOnRelatedElement) : IfcConnectionGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_CurveOnRelatingElement)); e->setArgument(1,(v2_CurveOnRelatedElement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConnectionGeometry -bool IfcConnectionGeometry::is(Type::Enum v) const { return v == Type::IfcConnectionGeometry; } -Type::Enum IfcConnectionGeometry::type() const { return Type::IfcConnectionGeometry; } + + +const IfcParse::entity& IfcConnectionGeometry::declaration() const { return *IfcConnectionGeometry_type; } Type::Enum IfcConnectionGeometry::Class() { return Type::IfcConnectionGeometry; } -IfcConnectionGeometry::IfcConnectionGeometry(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcConnectionGeometry)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConnectionGeometry::IfcConnectionGeometry() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcConnectionGeometry::IfcConnectionGeometry(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcConnectionGeometry)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConnectionGeometry::IfcConnectionGeometry() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConnectionPointEccentricity -bool IfcConnectionPointEccentricity::hasEccentricityInX() const { return !entity->getArgument(2)->isNull(); } -double IfcConnectionPointEccentricity::EccentricityInX() const { return *entity->getArgument(2); } -void IfcConnectionPointEccentricity::setEccentricityInX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcConnectionPointEccentricity::hasEccentricityInY() const { return !entity->getArgument(3)->isNull(); } -double IfcConnectionPointEccentricity::EccentricityInY() const { return *entity->getArgument(3); } -void IfcConnectionPointEccentricity::setEccentricityInY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcConnectionPointEccentricity::hasEccentricityInZ() const { return !entity->getArgument(4)->isNull(); } -double IfcConnectionPointEccentricity::EccentricityInZ() const { return *entity->getArgument(4); } -void IfcConnectionPointEccentricity::setEccentricityInZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcConnectionPointEccentricity::is(Type::Enum v) const { return v == Type::IfcConnectionPointEccentricity || IfcConnectionPointGeometry::is(v); } -Type::Enum IfcConnectionPointEccentricity::type() const { return Type::IfcConnectionPointEccentricity; } +bool IfcConnectionPointEccentricity::hasEccentricityInX() const { return !data_->getArgument(2)->isNull(); } +double IfcConnectionPointEccentricity::EccentricityInX() const { return *data_->getArgument(2); } +void IfcConnectionPointEccentricity::setEccentricityInX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcConnectionPointEccentricity::hasEccentricityInY() const { return !data_->getArgument(3)->isNull(); } +double IfcConnectionPointEccentricity::EccentricityInY() const { return *data_->getArgument(3); } +void IfcConnectionPointEccentricity::setEccentricityInY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcConnectionPointEccentricity::hasEccentricityInZ() const { return !data_->getArgument(4)->isNull(); } +double IfcConnectionPointEccentricity::EccentricityInZ() const { return *data_->getArgument(4); } +void IfcConnectionPointEccentricity::setEccentricityInZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcConnectionPointEccentricity::declaration() const { return *IfcConnectionPointEccentricity_type; } Type::Enum IfcConnectionPointEccentricity::Class() { return Type::IfcConnectionPointEccentricity; } -IfcConnectionPointEccentricity::IfcConnectionPointEccentricity(IfcAbstractEntity* e) : IfcConnectionPointGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionPointEccentricity)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConnectionPointEccentricity::IfcConnectionPointEccentricity(IfcPointOrVertexPoint* v1_PointOnRelatingElement, IfcPointOrVertexPoint* v2_PointOnRelatedElement, boost::optional< double > v3_EccentricityInX, boost::optional< double > v4_EccentricityInY, boost::optional< double > v5_EccentricityInZ) : IfcConnectionPointGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_PointOnRelatingElement)); e->setArgument(1,(v2_PointOnRelatedElement)); if (v3_EccentricityInX) { e->setArgument(2,(*v3_EccentricityInX)); } else { e->setArgument(2); } if (v4_EccentricityInY) { e->setArgument(3,(*v4_EccentricityInY)); } else { e->setArgument(3); } if (v5_EccentricityInZ) { e->setArgument(4,(*v5_EccentricityInZ)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcConnectionPointEccentricity::IfcConnectionPointEccentricity(IfcAbstractEntity* e) : IfcConnectionPointGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionPointEccentricity)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConnectionPointEccentricity::IfcConnectionPointEccentricity(IfcPointOrVertexPoint* v1_PointOnRelatingElement, IfcPointOrVertexPoint* v2_PointOnRelatedElement, boost::optional< double > v3_EccentricityInX, boost::optional< double > v4_EccentricityInY, boost::optional< double > v5_EccentricityInZ) : IfcConnectionPointGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_PointOnRelatingElement)); e->setArgument(1,(v2_PointOnRelatedElement)); if (v3_EccentricityInX) { e->setArgument(2,(*v3_EccentricityInX)); } else { e->setArgument(2); } if (v4_EccentricityInY) { e->setArgument(3,(*v4_EccentricityInY)); } else { e->setArgument(3); } if (v5_EccentricityInZ) { e->setArgument(4,(*v5_EccentricityInZ)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConnectionPointGeometry -IfcPointOrVertexPoint* IfcConnectionPointGeometry::PointOnRelatingElement() const { return (IfcPointOrVertexPoint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcConnectionPointGeometry::setPointOnRelatingElement(IfcPointOrVertexPoint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcConnectionPointGeometry::hasPointOnRelatedElement() const { return !entity->getArgument(1)->isNull(); } -IfcPointOrVertexPoint* IfcConnectionPointGeometry::PointOnRelatedElement() const { return (IfcPointOrVertexPoint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcConnectionPointGeometry::setPointOnRelatedElement(IfcPointOrVertexPoint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcConnectionPointGeometry::is(Type::Enum v) const { return v == Type::IfcConnectionPointGeometry || IfcConnectionGeometry::is(v); } -Type::Enum IfcConnectionPointGeometry::type() const { return Type::IfcConnectionPointGeometry; } +IfcPointOrVertexPoint* IfcConnectionPointGeometry::PointOnRelatingElement() const { return (IfcPointOrVertexPoint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcConnectionPointGeometry::setPointOnRelatingElement(IfcPointOrVertexPoint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcConnectionPointGeometry::hasPointOnRelatedElement() const { return !data_->getArgument(1)->isNull(); } +IfcPointOrVertexPoint* IfcConnectionPointGeometry::PointOnRelatedElement() const { return (IfcPointOrVertexPoint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcConnectionPointGeometry::setPointOnRelatedElement(IfcPointOrVertexPoint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcConnectionPointGeometry::declaration() const { return *IfcConnectionPointGeometry_type; } Type::Enum IfcConnectionPointGeometry::Class() { return Type::IfcConnectionPointGeometry; } -IfcConnectionPointGeometry::IfcConnectionPointGeometry(IfcAbstractEntity* e) : IfcConnectionGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionPointGeometry)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConnectionPointGeometry::IfcConnectionPointGeometry(IfcPointOrVertexPoint* v1_PointOnRelatingElement, IfcPointOrVertexPoint* v2_PointOnRelatedElement) : IfcConnectionGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_PointOnRelatingElement)); e->setArgument(1,(v2_PointOnRelatedElement)); entity = e; EntityBuffer::Add(this); } +IfcConnectionPointGeometry::IfcConnectionPointGeometry(IfcAbstractEntity* e) : IfcConnectionGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionPointGeometry)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConnectionPointGeometry::IfcConnectionPointGeometry(IfcPointOrVertexPoint* v1_PointOnRelatingElement, IfcPointOrVertexPoint* v2_PointOnRelatedElement) : IfcConnectionGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_PointOnRelatingElement)); e->setArgument(1,(v2_PointOnRelatedElement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConnectionPortGeometry -IfcAxis2Placement* IfcConnectionPortGeometry::LocationAtRelatingElement() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcConnectionPortGeometry::setLocationAtRelatingElement(IfcAxis2Placement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcConnectionPortGeometry::hasLocationAtRelatedElement() const { return !entity->getArgument(1)->isNull(); } -IfcAxis2Placement* IfcConnectionPortGeometry::LocationAtRelatedElement() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcConnectionPortGeometry::setLocationAtRelatedElement(IfcAxis2Placement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcProfileDef* IfcConnectionPortGeometry::ProfileOfPort() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcConnectionPortGeometry::setProfileOfPort(IfcProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcConnectionPortGeometry::is(Type::Enum v) const { return v == Type::IfcConnectionPortGeometry || IfcConnectionGeometry::is(v); } -Type::Enum IfcConnectionPortGeometry::type() const { return Type::IfcConnectionPortGeometry; } +IfcAxis2Placement* IfcConnectionPortGeometry::LocationAtRelatingElement() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcConnectionPortGeometry::setLocationAtRelatingElement(IfcAxis2Placement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcConnectionPortGeometry::hasLocationAtRelatedElement() const { return !data_->getArgument(1)->isNull(); } +IfcAxis2Placement* IfcConnectionPortGeometry::LocationAtRelatedElement() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcConnectionPortGeometry::setLocationAtRelatedElement(IfcAxis2Placement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcProfileDef* IfcConnectionPortGeometry::ProfileOfPort() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcConnectionPortGeometry::setProfileOfPort(IfcProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcConnectionPortGeometry::declaration() const { return *IfcConnectionPortGeometry_type; } Type::Enum IfcConnectionPortGeometry::Class() { return Type::IfcConnectionPortGeometry; } -IfcConnectionPortGeometry::IfcConnectionPortGeometry(IfcAbstractEntity* e) : IfcConnectionGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionPortGeometry)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConnectionPortGeometry::IfcConnectionPortGeometry(IfcAxis2Placement* v1_LocationAtRelatingElement, IfcAxis2Placement* v2_LocationAtRelatedElement, IfcProfileDef* v3_ProfileOfPort) : IfcConnectionGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_LocationAtRelatingElement)); e->setArgument(1,(v2_LocationAtRelatedElement)); e->setArgument(2,(v3_ProfileOfPort)); entity = e; EntityBuffer::Add(this); } +IfcConnectionPortGeometry::IfcConnectionPortGeometry(IfcAbstractEntity* e) : IfcConnectionGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionPortGeometry)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConnectionPortGeometry::IfcConnectionPortGeometry(IfcAxis2Placement* v1_LocationAtRelatingElement, IfcAxis2Placement* v2_LocationAtRelatedElement, IfcProfileDef* v3_ProfileOfPort) : IfcConnectionGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_LocationAtRelatingElement)); e->setArgument(1,(v2_LocationAtRelatedElement)); e->setArgument(2,(v3_ProfileOfPort)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConnectionSurfaceGeometry -IfcSurfaceOrFaceSurface* IfcConnectionSurfaceGeometry::SurfaceOnRelatingElement() const { return (IfcSurfaceOrFaceSurface*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcConnectionSurfaceGeometry::setSurfaceOnRelatingElement(IfcSurfaceOrFaceSurface* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcConnectionSurfaceGeometry::hasSurfaceOnRelatedElement() const { return !entity->getArgument(1)->isNull(); } -IfcSurfaceOrFaceSurface* IfcConnectionSurfaceGeometry::SurfaceOnRelatedElement() const { return (IfcSurfaceOrFaceSurface*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcConnectionSurfaceGeometry::setSurfaceOnRelatedElement(IfcSurfaceOrFaceSurface* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcConnectionSurfaceGeometry::is(Type::Enum v) const { return v == Type::IfcConnectionSurfaceGeometry || IfcConnectionGeometry::is(v); } -Type::Enum IfcConnectionSurfaceGeometry::type() const { return Type::IfcConnectionSurfaceGeometry; } +IfcSurfaceOrFaceSurface* IfcConnectionSurfaceGeometry::SurfaceOnRelatingElement() const { return (IfcSurfaceOrFaceSurface*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcConnectionSurfaceGeometry::setSurfaceOnRelatingElement(IfcSurfaceOrFaceSurface* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcConnectionSurfaceGeometry::hasSurfaceOnRelatedElement() const { return !data_->getArgument(1)->isNull(); } +IfcSurfaceOrFaceSurface* IfcConnectionSurfaceGeometry::SurfaceOnRelatedElement() const { return (IfcSurfaceOrFaceSurface*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcConnectionSurfaceGeometry::setSurfaceOnRelatedElement(IfcSurfaceOrFaceSurface* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcConnectionSurfaceGeometry::declaration() const { return *IfcConnectionSurfaceGeometry_type; } Type::Enum IfcConnectionSurfaceGeometry::Class() { return Type::IfcConnectionSurfaceGeometry; } -IfcConnectionSurfaceGeometry::IfcConnectionSurfaceGeometry(IfcAbstractEntity* e) : IfcConnectionGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionSurfaceGeometry)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConnectionSurfaceGeometry::IfcConnectionSurfaceGeometry(IfcSurfaceOrFaceSurface* v1_SurfaceOnRelatingElement, IfcSurfaceOrFaceSurface* v2_SurfaceOnRelatedElement) : IfcConnectionGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SurfaceOnRelatingElement)); e->setArgument(1,(v2_SurfaceOnRelatedElement)); entity = e; EntityBuffer::Add(this); } +IfcConnectionSurfaceGeometry::IfcConnectionSurfaceGeometry(IfcAbstractEntity* e) : IfcConnectionGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionSurfaceGeometry)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConnectionSurfaceGeometry::IfcConnectionSurfaceGeometry(IfcSurfaceOrFaceSurface* v1_SurfaceOnRelatingElement, IfcSurfaceOrFaceSurface* v2_SurfaceOnRelatedElement) : IfcConnectionGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SurfaceOnRelatingElement)); e->setArgument(1,(v2_SurfaceOnRelatedElement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstraint -std::string IfcConstraint::Name() const { return *entity->getArgument(0); } -void IfcConstraint::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcConstraint::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcConstraint::Description() const { return *entity->getArgument(1); } -void IfcConstraint::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcConstraintEnum::IfcConstraintEnum IfcConstraint::ConstraintGrade() const { return IfcConstraintEnum::FromString(*entity->getArgument(2)); } -void IfcConstraint::setConstraintGrade(IfcConstraintEnum::IfcConstraintEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v,IfcConstraintEnum::ToString(v)); } -bool IfcConstraint::hasConstraintSource() const { return !entity->getArgument(3)->isNull(); } -std::string IfcConstraint::ConstraintSource() const { return *entity->getArgument(3); } -void IfcConstraint::setConstraintSource(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcConstraint::hasCreatingActor() const { return !entity->getArgument(4)->isNull(); } -IfcActorSelect* IfcConstraint::CreatingActor() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcConstraint::setCreatingActor(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcConstraint::hasCreationTime() const { return !entity->getArgument(5)->isNull(); } -IfcDateTimeSelect* IfcConstraint::CreationTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcConstraint::setCreationTime(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcConstraint::hasUserDefinedGrade() const { return !entity->getArgument(6)->isNull(); } -std::string IfcConstraint::UserDefinedGrade() const { return *entity->getArgument(6); } -void IfcConstraint::setUserDefinedGrade(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcConstraintClassificationRelationship::list::ptr IfcConstraint::ClassifiedAs() const { return entity->getInverse(Type::IfcConstraintClassificationRelationship, 0)->as(); } -IfcConstraintRelationship::list::ptr IfcConstraint::RelatesConstraints() const { return entity->getInverse(Type::IfcConstraintRelationship, 2)->as(); } -IfcConstraintRelationship::list::ptr IfcConstraint::IsRelatedWith() const { return entity->getInverse(Type::IfcConstraintRelationship, 3)->as(); } -IfcPropertyConstraintRelationship::list::ptr IfcConstraint::PropertiesForConstraint() const { return entity->getInverse(Type::IfcPropertyConstraintRelationship, 0)->as(); } -IfcConstraintAggregationRelationship::list::ptr IfcConstraint::Aggregates() const { return entity->getInverse(Type::IfcConstraintAggregationRelationship, 2)->as(); } -IfcConstraintAggregationRelationship::list::ptr IfcConstraint::IsAggregatedIn() const { return entity->getInverse(Type::IfcConstraintAggregationRelationship, 3)->as(); } -bool IfcConstraint::is(Type::Enum v) const { return v == Type::IfcConstraint; } -Type::Enum IfcConstraint::type() const { return Type::IfcConstraint; } +std::string IfcConstraint::Name() const { return *data_->getArgument(0); } +void IfcConstraint::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcConstraint::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcConstraint::Description() const { return *data_->getArgument(1); } +void IfcConstraint::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcConstraintEnum::IfcConstraintEnum IfcConstraint::ConstraintGrade() const { return IfcConstraintEnum::FromString(*data_->getArgument(2)); } +void IfcConstraint::setConstraintGrade(IfcConstraintEnum::IfcConstraintEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v,IfcConstraintEnum::ToString(v)); } +bool IfcConstraint::hasConstraintSource() const { return !data_->getArgument(3)->isNull(); } +std::string IfcConstraint::ConstraintSource() const { return *data_->getArgument(3); } +void IfcConstraint::setConstraintSource(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcConstraint::hasCreatingActor() const { return !data_->getArgument(4)->isNull(); } +IfcActorSelect* IfcConstraint::CreatingActor() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcConstraint::setCreatingActor(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcConstraint::hasCreationTime() const { return !data_->getArgument(5)->isNull(); } +IfcDateTimeSelect* IfcConstraint::CreationTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcConstraint::setCreationTime(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcConstraint::hasUserDefinedGrade() const { return !data_->getArgument(6)->isNull(); } +std::string IfcConstraint::UserDefinedGrade() const { return *data_->getArgument(6); } +void IfcConstraint::setUserDefinedGrade(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + +IfcConstraintClassificationRelationship::list::ptr IfcConstraint::ClassifiedAs() const { return data_->getInverse(Type::IfcConstraintClassificationRelationship, 0)->as(); } +IfcConstraintRelationship::list::ptr IfcConstraint::RelatesConstraints() const { return data_->getInverse(Type::IfcConstraintRelationship, 2)->as(); } +IfcConstraintRelationship::list::ptr IfcConstraint::IsRelatedWith() const { return data_->getInverse(Type::IfcConstraintRelationship, 3)->as(); } +IfcPropertyConstraintRelationship::list::ptr IfcConstraint::PropertiesForConstraint() const { return data_->getInverse(Type::IfcPropertyConstraintRelationship, 0)->as(); } +IfcConstraintAggregationRelationship::list::ptr IfcConstraint::Aggregates() const { return data_->getInverse(Type::IfcConstraintAggregationRelationship, 2)->as(); } +IfcConstraintAggregationRelationship::list::ptr IfcConstraint::IsAggregatedIn() const { return data_->getInverse(Type::IfcConstraintAggregationRelationship, 3)->as(); } + +const IfcParse::entity& IfcConstraint::declaration() const { return *IfcConstraint_type; } Type::Enum IfcConstraint::Class() { return Type::IfcConstraint; } -IfcConstraint::IfcConstraint(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcConstraint)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstraint::IfcConstraint(std::string v1_Name, boost::optional< std::string > v2_Description, IfcConstraintEnum::IfcConstraintEnum v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, IfcActorSelect* v5_CreatingActor, IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,v3_ConstraintGrade,IfcConstraintEnum::ToString(v3_ConstraintGrade)); if (v4_ConstraintSource) { e->setArgument(3,(*v4_ConstraintSource)); } else { e->setArgument(3); } e->setArgument(4,(v5_CreatingActor)); e->setArgument(5,(v6_CreationTime)); if (v7_UserDefinedGrade) { e->setArgument(6,(*v7_UserDefinedGrade)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcConstraint::IfcConstraint(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcConstraint)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstraint::IfcConstraint(std::string v1_Name, boost::optional< std::string > v2_Description, IfcConstraintEnum::IfcConstraintEnum v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, IfcActorSelect* v5_CreatingActor, IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,v3_ConstraintGrade,IfcConstraintEnum::ToString(v3_ConstraintGrade)); if (v4_ConstraintSource) { e->setArgument(3,(*v4_ConstraintSource)); } else { e->setArgument(3); } e->setArgument(4,(v5_CreatingActor)); e->setArgument(5,(v6_CreationTime)); if (v7_UserDefinedGrade) { e->setArgument(6,(*v7_UserDefinedGrade)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstraintAggregationRelationship -bool IfcConstraintAggregationRelationship::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcConstraintAggregationRelationship::Name() const { return *entity->getArgument(0); } -void IfcConstraintAggregationRelationship::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcConstraintAggregationRelationship::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcConstraintAggregationRelationship::Description() const { return *entity->getArgument(1); } -void IfcConstraintAggregationRelationship::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcConstraint* IfcConstraintAggregationRelationship::RelatingConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcConstraintAggregationRelationship::setRelatingConstraint(IfcConstraint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcTemplatedEntityList< IfcConstraint >::ptr IfcConstraintAggregationRelationship::RelatedConstraints() const { IfcEntityList::ptr es = *entity->getArgument(3); return es->as(); } -void IfcConstraintAggregationRelationship::setRelatedConstraints(IfcTemplatedEntityList< IfcConstraint >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v->generalize()); } -IfcLogicalOperatorEnum::IfcLogicalOperatorEnum IfcConstraintAggregationRelationship::LogicalAggregator() const { return IfcLogicalOperatorEnum::FromString(*entity->getArgument(4)); } -void IfcConstraintAggregationRelationship::setLogicalAggregator(IfcLogicalOperatorEnum::IfcLogicalOperatorEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcLogicalOperatorEnum::ToString(v)); } -bool IfcConstraintAggregationRelationship::is(Type::Enum v) const { return v == Type::IfcConstraintAggregationRelationship; } -Type::Enum IfcConstraintAggregationRelationship::type() const { return Type::IfcConstraintAggregationRelationship; } +bool IfcConstraintAggregationRelationship::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcConstraintAggregationRelationship::Name() const { return *data_->getArgument(0); } +void IfcConstraintAggregationRelationship::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcConstraintAggregationRelationship::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcConstraintAggregationRelationship::Description() const { return *data_->getArgument(1); } +void IfcConstraintAggregationRelationship::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcConstraint* IfcConstraintAggregationRelationship::RelatingConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcConstraintAggregationRelationship::setRelatingConstraint(IfcConstraint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcTemplatedEntityList< IfcConstraint >::ptr IfcConstraintAggregationRelationship::RelatedConstraints() const { IfcEntityList::ptr es = *data_->getArgument(3); return es->as(); } +void IfcConstraintAggregationRelationship::setRelatedConstraints(IfcTemplatedEntityList< IfcConstraint >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v->generalize()); } +IfcLogicalOperatorEnum::IfcLogicalOperatorEnum IfcConstraintAggregationRelationship::LogicalAggregator() const { return IfcLogicalOperatorEnum::FromString(*data_->getArgument(4)); } +void IfcConstraintAggregationRelationship::setLogicalAggregator(IfcLogicalOperatorEnum::IfcLogicalOperatorEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcLogicalOperatorEnum::ToString(v)); } + + +const IfcParse::entity& IfcConstraintAggregationRelationship::declaration() const { return *IfcConstraintAggregationRelationship_type; } Type::Enum IfcConstraintAggregationRelationship::Class() { return Type::IfcConstraintAggregationRelationship; } -IfcConstraintAggregationRelationship::IfcConstraintAggregationRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcConstraintAggregationRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstraintAggregationRelationship::IfcConstraintAggregationRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcConstraint* v3_RelatingConstraint, IfcTemplatedEntityList< IfcConstraint >::ptr v4_RelatedConstraints, IfcLogicalOperatorEnum::IfcLogicalOperatorEnum v5_LogicalAggregator) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingConstraint)); e->setArgument(3,(v4_RelatedConstraints)->generalize()); e->setArgument(4,v5_LogicalAggregator,IfcLogicalOperatorEnum::ToString(v5_LogicalAggregator)); entity = e; EntityBuffer::Add(this); } +IfcConstraintAggregationRelationship::IfcConstraintAggregationRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcConstraintAggregationRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstraintAggregationRelationship::IfcConstraintAggregationRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcConstraint* v3_RelatingConstraint, IfcTemplatedEntityList< IfcConstraint >::ptr v4_RelatedConstraints, IfcLogicalOperatorEnum::IfcLogicalOperatorEnum v5_LogicalAggregator) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingConstraint)); e->setArgument(3,(v4_RelatedConstraints)->generalize()); e->setArgument(4,v5_LogicalAggregator,IfcLogicalOperatorEnum::ToString(v5_LogicalAggregator)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstraintClassificationRelationship -IfcConstraint* IfcConstraintClassificationRelationship::ClassifiedConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcConstraintClassificationRelationship::setClassifiedConstraint(IfcConstraint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcEntityList::ptr IfcConstraintClassificationRelationship::RelatedClassifications() const { return *entity->getArgument(1); } -void IfcConstraintClassificationRelationship::setRelatedClassifications(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcConstraintClassificationRelationship::is(Type::Enum v) const { return v == Type::IfcConstraintClassificationRelationship; } -Type::Enum IfcConstraintClassificationRelationship::type() const { return Type::IfcConstraintClassificationRelationship; } +IfcConstraint* IfcConstraintClassificationRelationship::ClassifiedConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcConstraintClassificationRelationship::setClassifiedConstraint(IfcConstraint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcEntityList::ptr IfcConstraintClassificationRelationship::RelatedClassifications() const { return *data_->getArgument(1); } +void IfcConstraintClassificationRelationship::setRelatedClassifications(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcConstraintClassificationRelationship::declaration() const { return *IfcConstraintClassificationRelationship_type; } Type::Enum IfcConstraintClassificationRelationship::Class() { return Type::IfcConstraintClassificationRelationship; } -IfcConstraintClassificationRelationship::IfcConstraintClassificationRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcConstraintClassificationRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstraintClassificationRelationship::IfcConstraintClassificationRelationship(IfcConstraint* v1_ClassifiedConstraint, IfcEntityList::ptr v2_RelatedClassifications) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ClassifiedConstraint)); e->setArgument(1,(v2_RelatedClassifications)); entity = e; EntityBuffer::Add(this); } +IfcConstraintClassificationRelationship::IfcConstraintClassificationRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcConstraintClassificationRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstraintClassificationRelationship::IfcConstraintClassificationRelationship(IfcConstraint* v1_ClassifiedConstraint, IfcEntityList::ptr v2_RelatedClassifications) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ClassifiedConstraint)); e->setArgument(1,(v2_RelatedClassifications)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstraintRelationship -bool IfcConstraintRelationship::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcConstraintRelationship::Name() const { return *entity->getArgument(0); } -void IfcConstraintRelationship::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcConstraintRelationship::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcConstraintRelationship::Description() const { return *entity->getArgument(1); } -void IfcConstraintRelationship::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcConstraint* IfcConstraintRelationship::RelatingConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcConstraintRelationship::setRelatingConstraint(IfcConstraint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcTemplatedEntityList< IfcConstraint >::ptr IfcConstraintRelationship::RelatedConstraints() const { IfcEntityList::ptr es = *entity->getArgument(3); return es->as(); } -void IfcConstraintRelationship::setRelatedConstraints(IfcTemplatedEntityList< IfcConstraint >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v->generalize()); } -bool IfcConstraintRelationship::is(Type::Enum v) const { return v == Type::IfcConstraintRelationship; } -Type::Enum IfcConstraintRelationship::type() const { return Type::IfcConstraintRelationship; } +bool IfcConstraintRelationship::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcConstraintRelationship::Name() const { return *data_->getArgument(0); } +void IfcConstraintRelationship::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcConstraintRelationship::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcConstraintRelationship::Description() const { return *data_->getArgument(1); } +void IfcConstraintRelationship::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcConstraint* IfcConstraintRelationship::RelatingConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcConstraintRelationship::setRelatingConstraint(IfcConstraint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcTemplatedEntityList< IfcConstraint >::ptr IfcConstraintRelationship::RelatedConstraints() const { IfcEntityList::ptr es = *data_->getArgument(3); return es->as(); } +void IfcConstraintRelationship::setRelatedConstraints(IfcTemplatedEntityList< IfcConstraint >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v->generalize()); } + + +const IfcParse::entity& IfcConstraintRelationship::declaration() const { return *IfcConstraintRelationship_type; } Type::Enum IfcConstraintRelationship::Class() { return Type::IfcConstraintRelationship; } -IfcConstraintRelationship::IfcConstraintRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcConstraintRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstraintRelationship::IfcConstraintRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcConstraint* v3_RelatingConstraint, IfcTemplatedEntityList< IfcConstraint >::ptr v4_RelatedConstraints) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingConstraint)); e->setArgument(3,(v4_RelatedConstraints)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcConstraintRelationship::IfcConstraintRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcConstraintRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstraintRelationship::IfcConstraintRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcConstraint* v3_RelatingConstraint, IfcTemplatedEntityList< IfcConstraint >::ptr v4_RelatedConstraints) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingConstraint)); e->setArgument(3,(v4_RelatedConstraints)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionEquipmentResource -bool IfcConstructionEquipmentResource::is(Type::Enum v) const { return v == Type::IfcConstructionEquipmentResource || IfcConstructionResource::is(v); } -Type::Enum IfcConstructionEquipmentResource::type() const { return Type::IfcConstructionEquipmentResource; } + + +const IfcParse::entity& IfcConstructionEquipmentResource::declaration() const { return *IfcConstructionEquipmentResource_type; } Type::Enum IfcConstructionEquipmentResource::Class() { return Type::IfcConstructionEquipmentResource; } -IfcConstructionEquipmentResource::IfcConstructionEquipmentResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionEquipmentResource)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstructionEquipmentResource::IfcConstructionEquipmentResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); entity = e; EntityBuffer::Add(this); } +IfcConstructionEquipmentResource::IfcConstructionEquipmentResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionEquipmentResource)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstructionEquipmentResource::IfcConstructionEquipmentResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionMaterialResource -bool IfcConstructionMaterialResource::hasSuppliers() const { return !entity->getArgument(9)->isNull(); } -IfcEntityList::ptr IfcConstructionMaterialResource::Suppliers() const { return *entity->getArgument(9); } -void IfcConstructionMaterialResource::setSuppliers(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcConstructionMaterialResource::hasUsageRatio() const { return !entity->getArgument(10)->isNull(); } -double IfcConstructionMaterialResource::UsageRatio() const { return *entity->getArgument(10); } -void IfcConstructionMaterialResource::setUsageRatio(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcConstructionMaterialResource::is(Type::Enum v) const { return v == Type::IfcConstructionMaterialResource || IfcConstructionResource::is(v); } -Type::Enum IfcConstructionMaterialResource::type() const { return Type::IfcConstructionMaterialResource; } +bool IfcConstructionMaterialResource::hasSuppliers() const { return !data_->getArgument(9)->isNull(); } +IfcEntityList::ptr IfcConstructionMaterialResource::Suppliers() const { return *data_->getArgument(9); } +void IfcConstructionMaterialResource::setSuppliers(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcConstructionMaterialResource::hasUsageRatio() const { return !data_->getArgument(10)->isNull(); } +double IfcConstructionMaterialResource::UsageRatio() const { return *data_->getArgument(10); } +void IfcConstructionMaterialResource::setUsageRatio(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcConstructionMaterialResource::declaration() const { return *IfcConstructionMaterialResource_type; } Type::Enum IfcConstructionMaterialResource::Class() { return Type::IfcConstructionMaterialResource; } -IfcConstructionMaterialResource::IfcConstructionMaterialResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionMaterialResource)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstructionMaterialResource::IfcConstructionMaterialResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity, boost::optional< IfcEntityList::ptr > v10_Suppliers, boost::optional< double > v11_UsageRatio) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); if (v10_Suppliers) { e->setArgument(9,(*v10_Suppliers)); } else { e->setArgument(9); } if (v11_UsageRatio) { e->setArgument(10,(*v11_UsageRatio)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcConstructionMaterialResource::IfcConstructionMaterialResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionMaterialResource)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstructionMaterialResource::IfcConstructionMaterialResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity, boost::optional< IfcEntityList::ptr > v10_Suppliers, boost::optional< double > v11_UsageRatio) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); if (v10_Suppliers) { e->setArgument(9,(*v10_Suppliers)); } else { e->setArgument(9); } if (v11_UsageRatio) { e->setArgument(10,(*v11_UsageRatio)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionProductResource -bool IfcConstructionProductResource::is(Type::Enum v) const { return v == Type::IfcConstructionProductResource || IfcConstructionResource::is(v); } -Type::Enum IfcConstructionProductResource::type() const { return Type::IfcConstructionProductResource; } + + +const IfcParse::entity& IfcConstructionProductResource::declaration() const { return *IfcConstructionProductResource_type; } Type::Enum IfcConstructionProductResource::Class() { return Type::IfcConstructionProductResource; } -IfcConstructionProductResource::IfcConstructionProductResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionProductResource)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstructionProductResource::IfcConstructionProductResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); entity = e; EntityBuffer::Add(this); } +IfcConstructionProductResource::IfcConstructionProductResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionProductResource)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstructionProductResource::IfcConstructionProductResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionResource -bool IfcConstructionResource::hasResourceIdentifier() const { return !entity->getArgument(5)->isNull(); } -std::string IfcConstructionResource::ResourceIdentifier() const { return *entity->getArgument(5); } -void IfcConstructionResource::setResourceIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcConstructionResource::hasResourceGroup() const { return !entity->getArgument(6)->isNull(); } -std::string IfcConstructionResource::ResourceGroup() const { return *entity->getArgument(6); } -void IfcConstructionResource::setResourceGroup(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcConstructionResource::hasResourceConsumption() const { return !entity->getArgument(7)->isNull(); } -IfcResourceConsumptionEnum::IfcResourceConsumptionEnum IfcConstructionResource::ResourceConsumption() const { return IfcResourceConsumptionEnum::FromString(*entity->getArgument(7)); } -void IfcConstructionResource::setResourceConsumption(IfcResourceConsumptionEnum::IfcResourceConsumptionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcResourceConsumptionEnum::ToString(v)); } -bool IfcConstructionResource::hasBaseQuantity() const { return !entity->getArgument(8)->isNull(); } -IfcMeasureWithUnit* IfcConstructionResource::BaseQuantity() const { return (IfcMeasureWithUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcConstructionResource::setBaseQuantity(IfcMeasureWithUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcConstructionResource::is(Type::Enum v) const { return v == Type::IfcConstructionResource || IfcResource::is(v); } -Type::Enum IfcConstructionResource::type() const { return Type::IfcConstructionResource; } +bool IfcConstructionResource::hasResourceIdentifier() const { return !data_->getArgument(5)->isNull(); } +std::string IfcConstructionResource::ResourceIdentifier() const { return *data_->getArgument(5); } +void IfcConstructionResource::setResourceIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcConstructionResource::hasResourceGroup() const { return !data_->getArgument(6)->isNull(); } +std::string IfcConstructionResource::ResourceGroup() const { return *data_->getArgument(6); } +void IfcConstructionResource::setResourceGroup(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcConstructionResource::hasResourceConsumption() const { return !data_->getArgument(7)->isNull(); } +IfcResourceConsumptionEnum::IfcResourceConsumptionEnum IfcConstructionResource::ResourceConsumption() const { return IfcResourceConsumptionEnum::FromString(*data_->getArgument(7)); } +void IfcConstructionResource::setResourceConsumption(IfcResourceConsumptionEnum::IfcResourceConsumptionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcResourceConsumptionEnum::ToString(v)); } +bool IfcConstructionResource::hasBaseQuantity() const { return !data_->getArgument(8)->isNull(); } +IfcMeasureWithUnit* IfcConstructionResource::BaseQuantity() const { return (IfcMeasureWithUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcConstructionResource::setBaseQuantity(IfcMeasureWithUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcConstructionResource::declaration() const { return *IfcConstructionResource_type; } Type::Enum IfcConstructionResource::Class() { return Type::IfcConstructionResource; } -IfcConstructionResource::IfcConstructionResource(IfcAbstractEntity* e) : IfcResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionResource)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstructionResource::IfcConstructionResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity) : IfcResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); entity = e; EntityBuffer::Add(this); } +IfcConstructionResource::IfcConstructionResource(IfcAbstractEntity* e) : IfcResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionResource)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstructionResource::IfcConstructionResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity) : IfcResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcContextDependentUnit -std::string IfcContextDependentUnit::Name() const { return *entity->getArgument(2); } -void IfcContextDependentUnit::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcContextDependentUnit::is(Type::Enum v) const { return v == Type::IfcContextDependentUnit || IfcNamedUnit::is(v); } -Type::Enum IfcContextDependentUnit::type() const { return Type::IfcContextDependentUnit; } +std::string IfcContextDependentUnit::Name() const { return *data_->getArgument(2); } +void IfcContextDependentUnit::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcContextDependentUnit::declaration() const { return *IfcContextDependentUnit_type; } Type::Enum IfcContextDependentUnit::Class() { return Type::IfcContextDependentUnit; } -IfcContextDependentUnit::IfcContextDependentUnit(IfcAbstractEntity* e) : IfcNamedUnit((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcContextDependentUnit)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcContextDependentUnit::IfcContextDependentUnit(IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType, std::string v3_Name) : IfcNamedUnit((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Dimensions)); e->setArgument(1,v2_UnitType,IfcUnitEnum::ToString(v2_UnitType)); e->setArgument(2,(v3_Name)); entity = e; EntityBuffer::Add(this); } +IfcContextDependentUnit::IfcContextDependentUnit(IfcAbstractEntity* e) : IfcNamedUnit((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcContextDependentUnit)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcContextDependentUnit::IfcContextDependentUnit(IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType, std::string v3_Name) : IfcNamedUnit((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Dimensions)); e->setArgument(1,v2_UnitType,IfcUnitEnum::ToString(v2_UnitType)); e->setArgument(2,(v3_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcControl -IfcRelAssignsToControl::list::ptr IfcControl::Controls() const { return entity->getInverse(Type::IfcRelAssignsToControl, 6)->as(); } -bool IfcControl::is(Type::Enum v) const { return v == Type::IfcControl || IfcObject::is(v); } -Type::Enum IfcControl::type() const { return Type::IfcControl; } + +IfcRelAssignsToControl::list::ptr IfcControl::Controls() const { return data_->getInverse(Type::IfcRelAssignsToControl, 6)->as(); } + +const IfcParse::entity& IfcControl::declaration() const { return *IfcControl_type; } Type::Enum IfcControl::Class() { return Type::IfcControl; } -IfcControl::IfcControl(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcControl)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcControl::IfcControl(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcControl::IfcControl(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcControl)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcControl::IfcControl(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcControllerType -IfcControllerTypeEnum::IfcControllerTypeEnum IfcControllerType::PredefinedType() const { return IfcControllerTypeEnum::FromString(*entity->getArgument(9)); } -void IfcControllerType::setPredefinedType(IfcControllerTypeEnum::IfcControllerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcControllerTypeEnum::ToString(v)); } -bool IfcControllerType::is(Type::Enum v) const { return v == Type::IfcControllerType || IfcDistributionControlElementType::is(v); } -Type::Enum IfcControllerType::type() const { return Type::IfcControllerType; } +IfcControllerTypeEnum::IfcControllerTypeEnum IfcControllerType::PredefinedType() const { return IfcControllerTypeEnum::FromString(*data_->getArgument(9)); } +void IfcControllerType::setPredefinedType(IfcControllerTypeEnum::IfcControllerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcControllerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcControllerType::declaration() const { return *IfcControllerType_type; } Type::Enum IfcControllerType::Class() { return Type::IfcControllerType; } -IfcControllerType::IfcControllerType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcControllerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcControllerType::IfcControllerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcControllerTypeEnum::IfcControllerTypeEnum v10_PredefinedType) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcControllerTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcControllerType::IfcControllerType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcControllerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcControllerType::IfcControllerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcControllerTypeEnum::IfcControllerTypeEnum v10_PredefinedType) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcControllerTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConversionBasedUnit -std::string IfcConversionBasedUnit::Name() const { return *entity->getArgument(2); } -void IfcConversionBasedUnit::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcMeasureWithUnit* IfcConversionBasedUnit::ConversionFactor() const { return (IfcMeasureWithUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcConversionBasedUnit::setConversionFactor(IfcMeasureWithUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcConversionBasedUnit::is(Type::Enum v) const { return v == Type::IfcConversionBasedUnit || IfcNamedUnit::is(v); } -Type::Enum IfcConversionBasedUnit::type() const { return Type::IfcConversionBasedUnit; } +std::string IfcConversionBasedUnit::Name() const { return *data_->getArgument(2); } +void IfcConversionBasedUnit::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcMeasureWithUnit* IfcConversionBasedUnit::ConversionFactor() const { return (IfcMeasureWithUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcConversionBasedUnit::setConversionFactor(IfcMeasureWithUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcConversionBasedUnit::declaration() const { return *IfcConversionBasedUnit_type; } Type::Enum IfcConversionBasedUnit::Class() { return Type::IfcConversionBasedUnit; } -IfcConversionBasedUnit::IfcConversionBasedUnit(IfcAbstractEntity* e) : IfcNamedUnit((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConversionBasedUnit)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConversionBasedUnit::IfcConversionBasedUnit(IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType, std::string v3_Name, IfcMeasureWithUnit* v4_ConversionFactor) : IfcNamedUnit((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Dimensions)); e->setArgument(1,v2_UnitType,IfcUnitEnum::ToString(v2_UnitType)); e->setArgument(2,(v3_Name)); e->setArgument(3,(v4_ConversionFactor)); entity = e; EntityBuffer::Add(this); } +IfcConversionBasedUnit::IfcConversionBasedUnit(IfcAbstractEntity* e) : IfcNamedUnit((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConversionBasedUnit)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConversionBasedUnit::IfcConversionBasedUnit(IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType, std::string v3_Name, IfcMeasureWithUnit* v4_ConversionFactor) : IfcNamedUnit((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Dimensions)); e->setArgument(1,v2_UnitType,IfcUnitEnum::ToString(v2_UnitType)); e->setArgument(2,(v3_Name)); e->setArgument(3,(v4_ConversionFactor)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCooledBeamType -IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum IfcCooledBeamType::PredefinedType() const { return IfcCooledBeamTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCooledBeamType::setPredefinedType(IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCooledBeamTypeEnum::ToString(v)); } -bool IfcCooledBeamType::is(Type::Enum v) const { return v == Type::IfcCooledBeamType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcCooledBeamType::type() const { return Type::IfcCooledBeamType; } +IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum IfcCooledBeamType::PredefinedType() const { return IfcCooledBeamTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCooledBeamType::setPredefinedType(IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCooledBeamTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCooledBeamType::declaration() const { return *IfcCooledBeamType_type; } Type::Enum IfcCooledBeamType::Class() { return Type::IfcCooledBeamType; } -IfcCooledBeamType::IfcCooledBeamType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCooledBeamType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCooledBeamType::IfcCooledBeamType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCooledBeamTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCooledBeamType::IfcCooledBeamType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCooledBeamType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCooledBeamType::IfcCooledBeamType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCooledBeamTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCoolingTowerType -IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum IfcCoolingTowerType::PredefinedType() const { return IfcCoolingTowerTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCoolingTowerType::setPredefinedType(IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCoolingTowerTypeEnum::ToString(v)); } -bool IfcCoolingTowerType::is(Type::Enum v) const { return v == Type::IfcCoolingTowerType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcCoolingTowerType::type() const { return Type::IfcCoolingTowerType; } +IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum IfcCoolingTowerType::PredefinedType() const { return IfcCoolingTowerTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCoolingTowerType::setPredefinedType(IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCoolingTowerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCoolingTowerType::declaration() const { return *IfcCoolingTowerType_type; } Type::Enum IfcCoolingTowerType::Class() { return Type::IfcCoolingTowerType; } -IfcCoolingTowerType::IfcCoolingTowerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCoolingTowerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCoolingTowerType::IfcCoolingTowerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCoolingTowerTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCoolingTowerType::IfcCoolingTowerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCoolingTowerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCoolingTowerType::IfcCoolingTowerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCoolingTowerTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCoordinatedUniversalTimeOffset -int IfcCoordinatedUniversalTimeOffset::HourOffset() const { return *entity->getArgument(0); } -void IfcCoordinatedUniversalTimeOffset::setHourOffset(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcCoordinatedUniversalTimeOffset::hasMinuteOffset() const { return !entity->getArgument(1)->isNull(); } -int IfcCoordinatedUniversalTimeOffset::MinuteOffset() const { return *entity->getArgument(1); } -void IfcCoordinatedUniversalTimeOffset::setMinuteOffset(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcAheadOrBehind::IfcAheadOrBehind IfcCoordinatedUniversalTimeOffset::Sense() const { return IfcAheadOrBehind::FromString(*entity->getArgument(2)); } -void IfcCoordinatedUniversalTimeOffset::setSense(IfcAheadOrBehind::IfcAheadOrBehind v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v,IfcAheadOrBehind::ToString(v)); } -bool IfcCoordinatedUniversalTimeOffset::is(Type::Enum v) const { return v == Type::IfcCoordinatedUniversalTimeOffset; } -Type::Enum IfcCoordinatedUniversalTimeOffset::type() const { return Type::IfcCoordinatedUniversalTimeOffset; } +int IfcCoordinatedUniversalTimeOffset::HourOffset() const { return *data_->getArgument(0); } +void IfcCoordinatedUniversalTimeOffset::setHourOffset(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcCoordinatedUniversalTimeOffset::hasMinuteOffset() const { return !data_->getArgument(1)->isNull(); } +int IfcCoordinatedUniversalTimeOffset::MinuteOffset() const { return *data_->getArgument(1); } +void IfcCoordinatedUniversalTimeOffset::setMinuteOffset(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcAheadOrBehind::IfcAheadOrBehind IfcCoordinatedUniversalTimeOffset::Sense() const { return IfcAheadOrBehind::FromString(*data_->getArgument(2)); } +void IfcCoordinatedUniversalTimeOffset::setSense(IfcAheadOrBehind::IfcAheadOrBehind v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v,IfcAheadOrBehind::ToString(v)); } + + +const IfcParse::entity& IfcCoordinatedUniversalTimeOffset::declaration() const { return *IfcCoordinatedUniversalTimeOffset_type; } Type::Enum IfcCoordinatedUniversalTimeOffset::Class() { return Type::IfcCoordinatedUniversalTimeOffset; } -IfcCoordinatedUniversalTimeOffset::IfcCoordinatedUniversalTimeOffset(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCoordinatedUniversalTimeOffset)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCoordinatedUniversalTimeOffset::IfcCoordinatedUniversalTimeOffset(int v1_HourOffset, boost::optional< int > v2_MinuteOffset, IfcAheadOrBehind::IfcAheadOrBehind v3_Sense) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_HourOffset)); if (v2_MinuteOffset) { e->setArgument(1,(*v2_MinuteOffset)); } else { e->setArgument(1); } e->setArgument(2,v3_Sense,IfcAheadOrBehind::ToString(v3_Sense)); entity = e; EntityBuffer::Add(this); } +IfcCoordinatedUniversalTimeOffset::IfcCoordinatedUniversalTimeOffset(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCoordinatedUniversalTimeOffset)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCoordinatedUniversalTimeOffset::IfcCoordinatedUniversalTimeOffset(int v1_HourOffset, boost::optional< int > v2_MinuteOffset, IfcAheadOrBehind::IfcAheadOrBehind v3_Sense) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_HourOffset)); if (v2_MinuteOffset) { e->setArgument(1,(*v2_MinuteOffset)); } else { e->setArgument(1); } e->setArgument(2,v3_Sense,IfcAheadOrBehind::ToString(v3_Sense)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCostItem -bool IfcCostItem::is(Type::Enum v) const { return v == Type::IfcCostItem || IfcControl::is(v); } -Type::Enum IfcCostItem::type() const { return Type::IfcCostItem; } + + +const IfcParse::entity& IfcCostItem::declaration() const { return *IfcCostItem_type; } Type::Enum IfcCostItem::Class() { return Type::IfcCostItem; } -IfcCostItem::IfcCostItem(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCostItem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCostItem::IfcCostItem(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcCostItem::IfcCostItem(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCostItem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCostItem::IfcCostItem(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCostSchedule -bool IfcCostSchedule::hasSubmittedBy() const { return !entity->getArgument(5)->isNull(); } -IfcActorSelect* IfcCostSchedule::SubmittedBy() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcCostSchedule::setSubmittedBy(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcCostSchedule::hasPreparedBy() const { return !entity->getArgument(6)->isNull(); } -IfcActorSelect* IfcCostSchedule::PreparedBy() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcCostSchedule::setPreparedBy(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcCostSchedule::hasSubmittedOn() const { return !entity->getArgument(7)->isNull(); } -IfcDateTimeSelect* IfcCostSchedule::SubmittedOn() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcCostSchedule::setSubmittedOn(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcCostSchedule::hasStatus() const { return !entity->getArgument(8)->isNull(); } -std::string IfcCostSchedule::Status() const { return *entity->getArgument(8); } -void IfcCostSchedule::setStatus(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcCostSchedule::hasTargetUsers() const { return !entity->getArgument(9)->isNull(); } -IfcEntityList::ptr IfcCostSchedule::TargetUsers() const { return *entity->getArgument(9); } -void IfcCostSchedule::setTargetUsers(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcCostSchedule::hasUpdateDate() const { return !entity->getArgument(10)->isNull(); } -IfcDateTimeSelect* IfcCostSchedule::UpdateDate() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcCostSchedule::setUpdateDate(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -std::string IfcCostSchedule::ID() const { return *entity->getArgument(11); } -void IfcCostSchedule::setID(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum IfcCostSchedule::PredefinedType() const { return IfcCostScheduleTypeEnum::FromString(*entity->getArgument(12)); } -void IfcCostSchedule::setPredefinedType(IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v,IfcCostScheduleTypeEnum::ToString(v)); } -bool IfcCostSchedule::is(Type::Enum v) const { return v == Type::IfcCostSchedule || IfcControl::is(v); } -Type::Enum IfcCostSchedule::type() const { return Type::IfcCostSchedule; } +bool IfcCostSchedule::hasSubmittedBy() const { return !data_->getArgument(5)->isNull(); } +IfcActorSelect* IfcCostSchedule::SubmittedBy() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcCostSchedule::setSubmittedBy(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcCostSchedule::hasPreparedBy() const { return !data_->getArgument(6)->isNull(); } +IfcActorSelect* IfcCostSchedule::PreparedBy() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcCostSchedule::setPreparedBy(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcCostSchedule::hasSubmittedOn() const { return !data_->getArgument(7)->isNull(); } +IfcDateTimeSelect* IfcCostSchedule::SubmittedOn() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcCostSchedule::setSubmittedOn(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcCostSchedule::hasStatus() const { return !data_->getArgument(8)->isNull(); } +std::string IfcCostSchedule::Status() const { return *data_->getArgument(8); } +void IfcCostSchedule::setStatus(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcCostSchedule::hasTargetUsers() const { return !data_->getArgument(9)->isNull(); } +IfcEntityList::ptr IfcCostSchedule::TargetUsers() const { return *data_->getArgument(9); } +void IfcCostSchedule::setTargetUsers(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcCostSchedule::hasUpdateDate() const { return !data_->getArgument(10)->isNull(); } +IfcDateTimeSelect* IfcCostSchedule::UpdateDate() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcCostSchedule::setUpdateDate(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +std::string IfcCostSchedule::ID() const { return *data_->getArgument(11); } +void IfcCostSchedule::setID(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum IfcCostSchedule::PredefinedType() const { return IfcCostScheduleTypeEnum::FromString(*data_->getArgument(12)); } +void IfcCostSchedule::setPredefinedType(IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v,IfcCostScheduleTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCostSchedule::declaration() const { return *IfcCostSchedule_type; } Type::Enum IfcCostSchedule::Class() { return Type::IfcCostSchedule; } -IfcCostSchedule::IfcCostSchedule(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCostSchedule)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCostSchedule::IfcCostSchedule(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcActorSelect* v6_SubmittedBy, IfcActorSelect* v7_PreparedBy, IfcDateTimeSelect* v8_SubmittedOn, boost::optional< std::string > v9_Status, boost::optional< IfcEntityList::ptr > v10_TargetUsers, IfcDateTimeSelect* v11_UpdateDate, std::string v12_ID, IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum v13_PredefinedType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_SubmittedBy)); e->setArgument(6,(v7_PreparedBy)); e->setArgument(7,(v8_SubmittedOn)); if (v9_Status) { e->setArgument(8,(*v9_Status)); } else { e->setArgument(8); } if (v10_TargetUsers) { e->setArgument(9,(*v10_TargetUsers)); } else { e->setArgument(9); } e->setArgument(10,(v11_UpdateDate)); e->setArgument(11,(v12_ID)); e->setArgument(12,v13_PredefinedType,IfcCostScheduleTypeEnum::ToString(v13_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCostSchedule::IfcCostSchedule(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCostSchedule)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCostSchedule::IfcCostSchedule(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcActorSelect* v6_SubmittedBy, IfcActorSelect* v7_PreparedBy, IfcDateTimeSelect* v8_SubmittedOn, boost::optional< std::string > v9_Status, boost::optional< IfcEntityList::ptr > v10_TargetUsers, IfcDateTimeSelect* v11_UpdateDate, std::string v12_ID, IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum v13_PredefinedType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_SubmittedBy)); e->setArgument(6,(v7_PreparedBy)); e->setArgument(7,(v8_SubmittedOn)); if (v9_Status) { e->setArgument(8,(*v9_Status)); } else { e->setArgument(8); } if (v10_TargetUsers) { e->setArgument(9,(*v10_TargetUsers)); } else { e->setArgument(9); } e->setArgument(10,(v11_UpdateDate)); e->setArgument(11,(v12_ID)); e->setArgument(12,v13_PredefinedType,IfcCostScheduleTypeEnum::ToString(v13_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCostValue -std::string IfcCostValue::CostType() const { return *entity->getArgument(6); } -void IfcCostValue::setCostType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcCostValue::hasCondition() const { return !entity->getArgument(7)->isNull(); } -std::string IfcCostValue::Condition() const { return *entity->getArgument(7); } -void IfcCostValue::setCondition(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcCostValue::is(Type::Enum v) const { return v == Type::IfcCostValue || IfcAppliedValue::is(v); } -Type::Enum IfcCostValue::type() const { return Type::IfcCostValue; } +std::string IfcCostValue::CostType() const { return *data_->getArgument(6); } +void IfcCostValue::setCostType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcCostValue::hasCondition() const { return !data_->getArgument(7)->isNull(); } +std::string IfcCostValue::Condition() const { return *data_->getArgument(7); } +void IfcCostValue::setCondition(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcCostValue::declaration() const { return *IfcCostValue_type; } Type::Enum IfcCostValue::Class() { return Type::IfcCostValue; } -IfcCostValue::IfcCostValue(IfcAbstractEntity* e) : IfcAppliedValue((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCostValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCostValue::IfcCostValue(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcAppliedValueSelect* v3_AppliedValue, IfcMeasureWithUnit* v4_UnitBasis, IfcDateTimeSelect* v5_ApplicableDate, IfcDateTimeSelect* v6_FixedUntilDate, std::string v7_CostType, boost::optional< std::string > v8_Condition) : IfcAppliedValue((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_AppliedValue)); e->setArgument(3,(v4_UnitBasis)); e->setArgument(4,(v5_ApplicableDate)); e->setArgument(5,(v6_FixedUntilDate)); e->setArgument(6,(v7_CostType)); if (v8_Condition) { e->setArgument(7,(*v8_Condition)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcCostValue::IfcCostValue(IfcAbstractEntity* e) : IfcAppliedValue((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCostValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCostValue::IfcCostValue(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcAppliedValueSelect* v3_AppliedValue, IfcMeasureWithUnit* v4_UnitBasis, IfcDateTimeSelect* v5_ApplicableDate, IfcDateTimeSelect* v6_FixedUntilDate, std::string v7_CostType, boost::optional< std::string > v8_Condition) : IfcAppliedValue((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_AppliedValue)); e->setArgument(3,(v4_UnitBasis)); e->setArgument(4,(v5_ApplicableDate)); e->setArgument(5,(v6_FixedUntilDate)); e->setArgument(6,(v7_CostType)); if (v8_Condition) { e->setArgument(7,(*v8_Condition)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCovering -bool IfcCovering::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCoveringTypeEnum::IfcCoveringTypeEnum IfcCovering::PredefinedType() const { return IfcCoveringTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCovering::setPredefinedType(IfcCoveringTypeEnum::IfcCoveringTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCoveringTypeEnum::ToString(v)); } -IfcRelCoversSpaces::list::ptr IfcCovering::CoversSpaces() const { return entity->getInverse(Type::IfcRelCoversSpaces, 5)->as(); } -IfcRelCoversBldgElements::list::ptr IfcCovering::Covers() const { return entity->getInverse(Type::IfcRelCoversBldgElements, 5)->as(); } -bool IfcCovering::is(Type::Enum v) const { return v == Type::IfcCovering || IfcBuildingElement::is(v); } -Type::Enum IfcCovering::type() const { return Type::IfcCovering; } +bool IfcCovering::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCoveringTypeEnum::IfcCoveringTypeEnum IfcCovering::PredefinedType() const { return IfcCoveringTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCovering::setPredefinedType(IfcCoveringTypeEnum::IfcCoveringTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCoveringTypeEnum::ToString(v)); } + +IfcRelCoversSpaces::list::ptr IfcCovering::CoversSpaces() const { return data_->getInverse(Type::IfcRelCoversSpaces, 5)->as(); } +IfcRelCoversBldgElements::list::ptr IfcCovering::Covers() const { return data_->getInverse(Type::IfcRelCoversBldgElements, 5)->as(); } + +const IfcParse::entity& IfcCovering::declaration() const { return *IfcCovering_type; } Type::Enum IfcCovering::Class() { return Type::IfcCovering; } -IfcCovering::IfcCovering(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCovering)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCovering::IfcCovering(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcCoveringTypeEnum::IfcCoveringTypeEnum > v9_PredefinedType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcCoveringTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCovering::IfcCovering(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCovering)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCovering::IfcCovering(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcCoveringTypeEnum::IfcCoveringTypeEnum > v9_PredefinedType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcCoveringTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCoveringType -IfcCoveringTypeEnum::IfcCoveringTypeEnum IfcCoveringType::PredefinedType() const { return IfcCoveringTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCoveringType::setPredefinedType(IfcCoveringTypeEnum::IfcCoveringTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCoveringTypeEnum::ToString(v)); } -bool IfcCoveringType::is(Type::Enum v) const { return v == Type::IfcCoveringType || IfcBuildingElementType::is(v); } -Type::Enum IfcCoveringType::type() const { return Type::IfcCoveringType; } +IfcCoveringTypeEnum::IfcCoveringTypeEnum IfcCoveringType::PredefinedType() const { return IfcCoveringTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCoveringType::setPredefinedType(IfcCoveringTypeEnum::IfcCoveringTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCoveringTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCoveringType::declaration() const { return *IfcCoveringType_type; } Type::Enum IfcCoveringType::Class() { return Type::IfcCoveringType; } -IfcCoveringType::IfcCoveringType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCoveringType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCoveringType::IfcCoveringType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCoveringTypeEnum::IfcCoveringTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCoveringTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCoveringType::IfcCoveringType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCoveringType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCoveringType::IfcCoveringType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCoveringTypeEnum::IfcCoveringTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCoveringTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCraneRailAShapeProfileDef -double IfcCraneRailAShapeProfileDef::OverallHeight() const { return *entity->getArgument(3); } -void IfcCraneRailAShapeProfileDef::setOverallHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcCraneRailAShapeProfileDef::BaseWidth2() const { return *entity->getArgument(4); } -void IfcCraneRailAShapeProfileDef::setBaseWidth2(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcCraneRailAShapeProfileDef::hasRadius() const { return !entity->getArgument(5)->isNull(); } -double IfcCraneRailAShapeProfileDef::Radius() const { return *entity->getArgument(5); } -void IfcCraneRailAShapeProfileDef::setRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcCraneRailAShapeProfileDef::HeadWidth() const { return *entity->getArgument(6); } -void IfcCraneRailAShapeProfileDef::setHeadWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -double IfcCraneRailAShapeProfileDef::HeadDepth2() const { return *entity->getArgument(7); } -void IfcCraneRailAShapeProfileDef::setHeadDepth2(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -double IfcCraneRailAShapeProfileDef::HeadDepth3() const { return *entity->getArgument(8); } -void IfcCraneRailAShapeProfileDef::setHeadDepth3(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -double IfcCraneRailAShapeProfileDef::WebThickness() const { return *entity->getArgument(9); } -void IfcCraneRailAShapeProfileDef::setWebThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -double IfcCraneRailAShapeProfileDef::BaseWidth4() const { return *entity->getArgument(10); } -void IfcCraneRailAShapeProfileDef::setBaseWidth4(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -double IfcCraneRailAShapeProfileDef::BaseDepth1() const { return *entity->getArgument(11); } -void IfcCraneRailAShapeProfileDef::setBaseDepth1(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -double IfcCraneRailAShapeProfileDef::BaseDepth2() const { return *entity->getArgument(12); } -void IfcCraneRailAShapeProfileDef::setBaseDepth2(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -double IfcCraneRailAShapeProfileDef::BaseDepth3() const { return *entity->getArgument(13); } -void IfcCraneRailAShapeProfileDef::setBaseDepth3(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcCraneRailAShapeProfileDef::hasCentreOfGravityInY() const { return !entity->getArgument(14)->isNull(); } -double IfcCraneRailAShapeProfileDef::CentreOfGravityInY() const { return *entity->getArgument(14); } -void IfcCraneRailAShapeProfileDef::setCentreOfGravityInY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcCraneRailAShapeProfileDef::is(Type::Enum v) const { return v == Type::IfcCraneRailAShapeProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcCraneRailAShapeProfileDef::type() const { return Type::IfcCraneRailAShapeProfileDef; } +double IfcCraneRailAShapeProfileDef::OverallHeight() const { return *data_->getArgument(3); } +void IfcCraneRailAShapeProfileDef::setOverallHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcCraneRailAShapeProfileDef::BaseWidth2() const { return *data_->getArgument(4); } +void IfcCraneRailAShapeProfileDef::setBaseWidth2(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcCraneRailAShapeProfileDef::hasRadius() const { return !data_->getArgument(5)->isNull(); } +double IfcCraneRailAShapeProfileDef::Radius() const { return *data_->getArgument(5); } +void IfcCraneRailAShapeProfileDef::setRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcCraneRailAShapeProfileDef::HeadWidth() const { return *data_->getArgument(6); } +void IfcCraneRailAShapeProfileDef::setHeadWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +double IfcCraneRailAShapeProfileDef::HeadDepth2() const { return *data_->getArgument(7); } +void IfcCraneRailAShapeProfileDef::setHeadDepth2(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +double IfcCraneRailAShapeProfileDef::HeadDepth3() const { return *data_->getArgument(8); } +void IfcCraneRailAShapeProfileDef::setHeadDepth3(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +double IfcCraneRailAShapeProfileDef::WebThickness() const { return *data_->getArgument(9); } +void IfcCraneRailAShapeProfileDef::setWebThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +double IfcCraneRailAShapeProfileDef::BaseWidth4() const { return *data_->getArgument(10); } +void IfcCraneRailAShapeProfileDef::setBaseWidth4(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +double IfcCraneRailAShapeProfileDef::BaseDepth1() const { return *data_->getArgument(11); } +void IfcCraneRailAShapeProfileDef::setBaseDepth1(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +double IfcCraneRailAShapeProfileDef::BaseDepth2() const { return *data_->getArgument(12); } +void IfcCraneRailAShapeProfileDef::setBaseDepth2(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +double IfcCraneRailAShapeProfileDef::BaseDepth3() const { return *data_->getArgument(13); } +void IfcCraneRailAShapeProfileDef::setBaseDepth3(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcCraneRailAShapeProfileDef::hasCentreOfGravityInY() const { return !data_->getArgument(14)->isNull(); } +double IfcCraneRailAShapeProfileDef::CentreOfGravityInY() const { return *data_->getArgument(14); } +void IfcCraneRailAShapeProfileDef::setCentreOfGravityInY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } + + +const IfcParse::entity& IfcCraneRailAShapeProfileDef::declaration() const { return *IfcCraneRailAShapeProfileDef_type; } Type::Enum IfcCraneRailAShapeProfileDef::Class() { return Type::IfcCraneRailAShapeProfileDef; } -IfcCraneRailAShapeProfileDef::IfcCraneRailAShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCraneRailAShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCraneRailAShapeProfileDef::IfcCraneRailAShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallHeight, double v5_BaseWidth2, boost::optional< double > v6_Radius, double v7_HeadWidth, double v8_HeadDepth2, double v9_HeadDepth3, double v10_WebThickness, double v11_BaseWidth4, double v12_BaseDepth1, double v13_BaseDepth2, double v14_BaseDepth3, boost::optional< double > v15_CentreOfGravityInY) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_OverallHeight)); e->setArgument(4,(v5_BaseWidth2)); if (v6_Radius) { e->setArgument(5,(*v6_Radius)); } else { e->setArgument(5); } e->setArgument(6,(v7_HeadWidth)); e->setArgument(7,(v8_HeadDepth2)); e->setArgument(8,(v9_HeadDepth3)); e->setArgument(9,(v10_WebThickness)); e->setArgument(10,(v11_BaseWidth4)); e->setArgument(11,(v12_BaseDepth1)); e->setArgument(12,(v13_BaseDepth2)); e->setArgument(13,(v14_BaseDepth3)); if (v15_CentreOfGravityInY) { e->setArgument(14,(*v15_CentreOfGravityInY)); } else { e->setArgument(14); } entity = e; EntityBuffer::Add(this); } +IfcCraneRailAShapeProfileDef::IfcCraneRailAShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCraneRailAShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCraneRailAShapeProfileDef::IfcCraneRailAShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallHeight, double v5_BaseWidth2, boost::optional< double > v6_Radius, double v7_HeadWidth, double v8_HeadDepth2, double v9_HeadDepth3, double v10_WebThickness, double v11_BaseWidth4, double v12_BaseDepth1, double v13_BaseDepth2, double v14_BaseDepth3, boost::optional< double > v15_CentreOfGravityInY) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_OverallHeight)); e->setArgument(4,(v5_BaseWidth2)); if (v6_Radius) { e->setArgument(5,(*v6_Radius)); } else { e->setArgument(5); } e->setArgument(6,(v7_HeadWidth)); e->setArgument(7,(v8_HeadDepth2)); e->setArgument(8,(v9_HeadDepth3)); e->setArgument(9,(v10_WebThickness)); e->setArgument(10,(v11_BaseWidth4)); e->setArgument(11,(v12_BaseDepth1)); e->setArgument(12,(v13_BaseDepth2)); e->setArgument(13,(v14_BaseDepth3)); if (v15_CentreOfGravityInY) { e->setArgument(14,(*v15_CentreOfGravityInY)); } else { e->setArgument(14); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCraneRailFShapeProfileDef -double IfcCraneRailFShapeProfileDef::OverallHeight() const { return *entity->getArgument(3); } -void IfcCraneRailFShapeProfileDef::setOverallHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcCraneRailFShapeProfileDef::HeadWidth() const { return *entity->getArgument(4); } -void IfcCraneRailFShapeProfileDef::setHeadWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcCraneRailFShapeProfileDef::hasRadius() const { return !entity->getArgument(5)->isNull(); } -double IfcCraneRailFShapeProfileDef::Radius() const { return *entity->getArgument(5); } -void IfcCraneRailFShapeProfileDef::setRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcCraneRailFShapeProfileDef::HeadDepth2() const { return *entity->getArgument(6); } -void IfcCraneRailFShapeProfileDef::setHeadDepth2(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -double IfcCraneRailFShapeProfileDef::HeadDepth3() const { return *entity->getArgument(7); } -void IfcCraneRailFShapeProfileDef::setHeadDepth3(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -double IfcCraneRailFShapeProfileDef::WebThickness() const { return *entity->getArgument(8); } -void IfcCraneRailFShapeProfileDef::setWebThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -double IfcCraneRailFShapeProfileDef::BaseDepth1() const { return *entity->getArgument(9); } -void IfcCraneRailFShapeProfileDef::setBaseDepth1(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -double IfcCraneRailFShapeProfileDef::BaseDepth2() const { return *entity->getArgument(10); } -void IfcCraneRailFShapeProfileDef::setBaseDepth2(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcCraneRailFShapeProfileDef::hasCentreOfGravityInY() const { return !entity->getArgument(11)->isNull(); } -double IfcCraneRailFShapeProfileDef::CentreOfGravityInY() const { return *entity->getArgument(11); } -void IfcCraneRailFShapeProfileDef::setCentreOfGravityInY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcCraneRailFShapeProfileDef::is(Type::Enum v) const { return v == Type::IfcCraneRailFShapeProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcCraneRailFShapeProfileDef::type() const { return Type::IfcCraneRailFShapeProfileDef; } +double IfcCraneRailFShapeProfileDef::OverallHeight() const { return *data_->getArgument(3); } +void IfcCraneRailFShapeProfileDef::setOverallHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcCraneRailFShapeProfileDef::HeadWidth() const { return *data_->getArgument(4); } +void IfcCraneRailFShapeProfileDef::setHeadWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcCraneRailFShapeProfileDef::hasRadius() const { return !data_->getArgument(5)->isNull(); } +double IfcCraneRailFShapeProfileDef::Radius() const { return *data_->getArgument(5); } +void IfcCraneRailFShapeProfileDef::setRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcCraneRailFShapeProfileDef::HeadDepth2() const { return *data_->getArgument(6); } +void IfcCraneRailFShapeProfileDef::setHeadDepth2(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +double IfcCraneRailFShapeProfileDef::HeadDepth3() const { return *data_->getArgument(7); } +void IfcCraneRailFShapeProfileDef::setHeadDepth3(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +double IfcCraneRailFShapeProfileDef::WebThickness() const { return *data_->getArgument(8); } +void IfcCraneRailFShapeProfileDef::setWebThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +double IfcCraneRailFShapeProfileDef::BaseDepth1() const { return *data_->getArgument(9); } +void IfcCraneRailFShapeProfileDef::setBaseDepth1(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +double IfcCraneRailFShapeProfileDef::BaseDepth2() const { return *data_->getArgument(10); } +void IfcCraneRailFShapeProfileDef::setBaseDepth2(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcCraneRailFShapeProfileDef::hasCentreOfGravityInY() const { return !data_->getArgument(11)->isNull(); } +double IfcCraneRailFShapeProfileDef::CentreOfGravityInY() const { return *data_->getArgument(11); } +void IfcCraneRailFShapeProfileDef::setCentreOfGravityInY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } + + +const IfcParse::entity& IfcCraneRailFShapeProfileDef::declaration() const { return *IfcCraneRailFShapeProfileDef_type; } Type::Enum IfcCraneRailFShapeProfileDef::Class() { return Type::IfcCraneRailFShapeProfileDef; } -IfcCraneRailFShapeProfileDef::IfcCraneRailFShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCraneRailFShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCraneRailFShapeProfileDef::IfcCraneRailFShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallHeight, double v5_HeadWidth, boost::optional< double > v6_Radius, double v7_HeadDepth2, double v8_HeadDepth3, double v9_WebThickness, double v10_BaseDepth1, double v11_BaseDepth2, boost::optional< double > v12_CentreOfGravityInY) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_OverallHeight)); e->setArgument(4,(v5_HeadWidth)); if (v6_Radius) { e->setArgument(5,(*v6_Radius)); } else { e->setArgument(5); } e->setArgument(6,(v7_HeadDepth2)); e->setArgument(7,(v8_HeadDepth3)); e->setArgument(8,(v9_WebThickness)); e->setArgument(9,(v10_BaseDepth1)); e->setArgument(10,(v11_BaseDepth2)); if (v12_CentreOfGravityInY) { e->setArgument(11,(*v12_CentreOfGravityInY)); } else { e->setArgument(11); } entity = e; EntityBuffer::Add(this); } +IfcCraneRailFShapeProfileDef::IfcCraneRailFShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCraneRailFShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCraneRailFShapeProfileDef::IfcCraneRailFShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallHeight, double v5_HeadWidth, boost::optional< double > v6_Radius, double v7_HeadDepth2, double v8_HeadDepth3, double v9_WebThickness, double v10_BaseDepth1, double v11_BaseDepth2, boost::optional< double > v12_CentreOfGravityInY) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_OverallHeight)); e->setArgument(4,(v5_HeadWidth)); if (v6_Radius) { e->setArgument(5,(*v6_Radius)); } else { e->setArgument(5); } e->setArgument(6,(v7_HeadDepth2)); e->setArgument(7,(v8_HeadDepth3)); e->setArgument(8,(v9_WebThickness)); e->setArgument(9,(v10_BaseDepth1)); e->setArgument(10,(v11_BaseDepth2)); if (v12_CentreOfGravityInY) { e->setArgument(11,(*v12_CentreOfGravityInY)); } else { e->setArgument(11); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCrewResource -bool IfcCrewResource::is(Type::Enum v) const { return v == Type::IfcCrewResource || IfcConstructionResource::is(v); } -Type::Enum IfcCrewResource::type() const { return Type::IfcCrewResource; } + + +const IfcParse::entity& IfcCrewResource::declaration() const { return *IfcCrewResource_type; } Type::Enum IfcCrewResource::Class() { return Type::IfcCrewResource; } -IfcCrewResource::IfcCrewResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCrewResource)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCrewResource::IfcCrewResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); entity = e; EntityBuffer::Add(this); } +IfcCrewResource::IfcCrewResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCrewResource)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCrewResource::IfcCrewResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCsgPrimitive3D -IfcAxis2Placement3D* IfcCsgPrimitive3D::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcCsgPrimitive3D::setPosition(IfcAxis2Placement3D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcCsgPrimitive3D::is(Type::Enum v) const { return v == Type::IfcCsgPrimitive3D || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcCsgPrimitive3D::type() const { return Type::IfcCsgPrimitive3D; } +IfcAxis2Placement3D* IfcCsgPrimitive3D::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcCsgPrimitive3D::setPosition(IfcAxis2Placement3D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcCsgPrimitive3D::declaration() const { return *IfcCsgPrimitive3D_type; } Type::Enum IfcCsgPrimitive3D::Class() { return Type::IfcCsgPrimitive3D; } -IfcCsgPrimitive3D::IfcCsgPrimitive3D(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCsgPrimitive3D)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCsgPrimitive3D::IfcCsgPrimitive3D(IfcAxis2Placement3D* v1_Position) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); entity = e; EntityBuffer::Add(this); } +IfcCsgPrimitive3D::IfcCsgPrimitive3D(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCsgPrimitive3D)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCsgPrimitive3D::IfcCsgPrimitive3D(IfcAxis2Placement3D* v1_Position) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCsgSolid -IfcCsgSelect* IfcCsgSolid::TreeRootExpression() const { return (IfcCsgSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcCsgSolid::setTreeRootExpression(IfcCsgSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcCsgSolid::is(Type::Enum v) const { return v == Type::IfcCsgSolid || IfcSolidModel::is(v); } -Type::Enum IfcCsgSolid::type() const { return Type::IfcCsgSolid; } +IfcCsgSelect* IfcCsgSolid::TreeRootExpression() const { return (IfcCsgSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcCsgSolid::setTreeRootExpression(IfcCsgSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcCsgSolid::declaration() const { return *IfcCsgSolid_type; } Type::Enum IfcCsgSolid::Class() { return Type::IfcCsgSolid; } -IfcCsgSolid::IfcCsgSolid(IfcAbstractEntity* e) : IfcSolidModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCsgSolid)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCsgSolid::IfcCsgSolid(IfcCsgSelect* v1_TreeRootExpression) : IfcSolidModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TreeRootExpression)); entity = e; EntityBuffer::Add(this); } +IfcCsgSolid::IfcCsgSolid(IfcAbstractEntity* e) : IfcSolidModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCsgSolid)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCsgSolid::IfcCsgSolid(IfcCsgSelect* v1_TreeRootExpression) : IfcSolidModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TreeRootExpression)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCurrencyRelationship -IfcMonetaryUnit* IfcCurrencyRelationship::RelatingMonetaryUnit() const { return (IfcMonetaryUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcCurrencyRelationship::setRelatingMonetaryUnit(IfcMonetaryUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcMonetaryUnit* IfcCurrencyRelationship::RelatedMonetaryUnit() const { return (IfcMonetaryUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcCurrencyRelationship::setRelatedMonetaryUnit(IfcMonetaryUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcCurrencyRelationship::ExchangeRate() const { return *entity->getArgument(2); } -void IfcCurrencyRelationship::setExchangeRate(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcDateAndTime* IfcCurrencyRelationship::RateDateTime() const { return (IfcDateAndTime*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcCurrencyRelationship::setRateDateTime(IfcDateAndTime* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcCurrencyRelationship::hasRateSource() const { return !entity->getArgument(4)->isNull(); } -IfcLibraryInformation* IfcCurrencyRelationship::RateSource() const { return (IfcLibraryInformation*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcCurrencyRelationship::setRateSource(IfcLibraryInformation* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcCurrencyRelationship::is(Type::Enum v) const { return v == Type::IfcCurrencyRelationship; } -Type::Enum IfcCurrencyRelationship::type() const { return Type::IfcCurrencyRelationship; } +IfcMonetaryUnit* IfcCurrencyRelationship::RelatingMonetaryUnit() const { return (IfcMonetaryUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcCurrencyRelationship::setRelatingMonetaryUnit(IfcMonetaryUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcMonetaryUnit* IfcCurrencyRelationship::RelatedMonetaryUnit() const { return (IfcMonetaryUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcCurrencyRelationship::setRelatedMonetaryUnit(IfcMonetaryUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcCurrencyRelationship::ExchangeRate() const { return *data_->getArgument(2); } +void IfcCurrencyRelationship::setExchangeRate(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcDateAndTime* IfcCurrencyRelationship::RateDateTime() const { return (IfcDateAndTime*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcCurrencyRelationship::setRateDateTime(IfcDateAndTime* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcCurrencyRelationship::hasRateSource() const { return !data_->getArgument(4)->isNull(); } +IfcLibraryInformation* IfcCurrencyRelationship::RateSource() const { return (IfcLibraryInformation*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcCurrencyRelationship::setRateSource(IfcLibraryInformation* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcCurrencyRelationship::declaration() const { return *IfcCurrencyRelationship_type; } Type::Enum IfcCurrencyRelationship::Class() { return Type::IfcCurrencyRelationship; } -IfcCurrencyRelationship::IfcCurrencyRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCurrencyRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCurrencyRelationship::IfcCurrencyRelationship(IfcMonetaryUnit* v1_RelatingMonetaryUnit, IfcMonetaryUnit* v2_RelatedMonetaryUnit, double v3_ExchangeRate, IfcDateAndTime* v4_RateDateTime, IfcLibraryInformation* v5_RateSource) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelatingMonetaryUnit)); e->setArgument(1,(v2_RelatedMonetaryUnit)); e->setArgument(2,(v3_ExchangeRate)); e->setArgument(3,(v4_RateDateTime)); e->setArgument(4,(v5_RateSource)); entity = e; EntityBuffer::Add(this); } +IfcCurrencyRelationship::IfcCurrencyRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCurrencyRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCurrencyRelationship::IfcCurrencyRelationship(IfcMonetaryUnit* v1_RelatingMonetaryUnit, IfcMonetaryUnit* v2_RelatedMonetaryUnit, double v3_ExchangeRate, IfcDateAndTime* v4_RateDateTime, IfcLibraryInformation* v5_RateSource) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelatingMonetaryUnit)); e->setArgument(1,(v2_RelatedMonetaryUnit)); e->setArgument(2,(v3_ExchangeRate)); e->setArgument(3,(v4_RateDateTime)); e->setArgument(4,(v5_RateSource)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCurtainWall -bool IfcCurtainWall::is(Type::Enum v) const { return v == Type::IfcCurtainWall || IfcBuildingElement::is(v); } -Type::Enum IfcCurtainWall::type() const { return Type::IfcCurtainWall; } + + +const IfcParse::entity& IfcCurtainWall::declaration() const { return *IfcCurtainWall_type; } Type::Enum IfcCurtainWall::Class() { return Type::IfcCurtainWall; } -IfcCurtainWall::IfcCurtainWall(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurtainWall)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCurtainWall::IfcCurtainWall(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcCurtainWall::IfcCurtainWall(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurtainWall)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCurtainWall::IfcCurtainWall(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCurtainWallType -IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum IfcCurtainWallType::PredefinedType() const { return IfcCurtainWallTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCurtainWallType::setPredefinedType(IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCurtainWallTypeEnum::ToString(v)); } -bool IfcCurtainWallType::is(Type::Enum v) const { return v == Type::IfcCurtainWallType || IfcBuildingElementType::is(v); } -Type::Enum IfcCurtainWallType::type() const { return Type::IfcCurtainWallType; } +IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum IfcCurtainWallType::PredefinedType() const { return IfcCurtainWallTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCurtainWallType::setPredefinedType(IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCurtainWallTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCurtainWallType::declaration() const { return *IfcCurtainWallType_type; } Type::Enum IfcCurtainWallType::Class() { return Type::IfcCurtainWallType; } -IfcCurtainWallType::IfcCurtainWallType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurtainWallType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCurtainWallType::IfcCurtainWallType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCurtainWallTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCurtainWallType::IfcCurtainWallType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurtainWallType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCurtainWallType::IfcCurtainWallType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcCurtainWallTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCurve -bool IfcCurve::is(Type::Enum v) const { return v == Type::IfcCurve || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcCurve::type() const { return Type::IfcCurve; } + + +const IfcParse::entity& IfcCurve::declaration() const { return *IfcCurve_type; } Type::Enum IfcCurve::Class() { return Type::IfcCurve; } -IfcCurve::IfcCurve(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCurve::IfcCurve() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcCurve::IfcCurve(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCurve::IfcCurve() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCurveBoundedPlane -IfcPlane* IfcCurveBoundedPlane::BasisSurface() const { return (IfcPlane*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcCurveBoundedPlane::setBasisSurface(IfcPlane* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcCurve* IfcCurveBoundedPlane::OuterBoundary() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcCurveBoundedPlane::setOuterBoundary(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcTemplatedEntityList< IfcCurve >::ptr IfcCurveBoundedPlane::InnerBoundaries() const { IfcEntityList::ptr es = *entity->getArgument(2); return es->as(); } -void IfcCurveBoundedPlane::setInnerBoundaries(IfcTemplatedEntityList< IfcCurve >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v->generalize()); } -bool IfcCurveBoundedPlane::is(Type::Enum v) const { return v == Type::IfcCurveBoundedPlane || IfcBoundedSurface::is(v); } -Type::Enum IfcCurveBoundedPlane::type() const { return Type::IfcCurveBoundedPlane; } +IfcPlane* IfcCurveBoundedPlane::BasisSurface() const { return (IfcPlane*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcCurveBoundedPlane::setBasisSurface(IfcPlane* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcCurve* IfcCurveBoundedPlane::OuterBoundary() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcCurveBoundedPlane::setOuterBoundary(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcTemplatedEntityList< IfcCurve >::ptr IfcCurveBoundedPlane::InnerBoundaries() const { IfcEntityList::ptr es = *data_->getArgument(2); return es->as(); } +void IfcCurveBoundedPlane::setInnerBoundaries(IfcTemplatedEntityList< IfcCurve >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v->generalize()); } + + +const IfcParse::entity& IfcCurveBoundedPlane::declaration() const { return *IfcCurveBoundedPlane_type; } Type::Enum IfcCurveBoundedPlane::Class() { return Type::IfcCurveBoundedPlane; } -IfcCurveBoundedPlane::IfcCurveBoundedPlane(IfcAbstractEntity* e) : IfcBoundedSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurveBoundedPlane)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCurveBoundedPlane::IfcCurveBoundedPlane(IfcPlane* v1_BasisSurface, IfcCurve* v2_OuterBoundary, IfcTemplatedEntityList< IfcCurve >::ptr v3_InnerBoundaries) : IfcBoundedSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisSurface)); e->setArgument(1,(v2_OuterBoundary)); e->setArgument(2,(v3_InnerBoundaries)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcCurveBoundedPlane::IfcCurveBoundedPlane(IfcAbstractEntity* e) : IfcBoundedSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurveBoundedPlane)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCurveBoundedPlane::IfcCurveBoundedPlane(IfcPlane* v1_BasisSurface, IfcCurve* v2_OuterBoundary, IfcTemplatedEntityList< IfcCurve >::ptr v3_InnerBoundaries) : IfcBoundedSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisSurface)); e->setArgument(1,(v2_OuterBoundary)); e->setArgument(2,(v3_InnerBoundaries)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCurveStyle -bool IfcCurveStyle::hasCurveFont() const { return !entity->getArgument(1)->isNull(); } -IfcCurveFontOrScaledCurveFontSelect* IfcCurveStyle::CurveFont() const { return (IfcCurveFontOrScaledCurveFontSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcCurveStyle::setCurveFont(IfcCurveFontOrScaledCurveFontSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcCurveStyle::hasCurveWidth() const { return !entity->getArgument(2)->isNull(); } -IfcSizeSelect* IfcCurveStyle::CurveWidth() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcCurveStyle::setCurveWidth(IfcSizeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcCurveStyle::hasCurveColour() const { return !entity->getArgument(3)->isNull(); } -IfcColour* IfcCurveStyle::CurveColour() const { return (IfcColour*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcCurveStyle::setCurveColour(IfcColour* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcCurveStyle::is(Type::Enum v) const { return v == Type::IfcCurveStyle || IfcPresentationStyle::is(v); } -Type::Enum IfcCurveStyle::type() const { return Type::IfcCurveStyle; } +bool IfcCurveStyle::hasCurveFont() const { return !data_->getArgument(1)->isNull(); } +IfcCurveFontOrScaledCurveFontSelect* IfcCurveStyle::CurveFont() const { return (IfcCurveFontOrScaledCurveFontSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcCurveStyle::setCurveFont(IfcCurveFontOrScaledCurveFontSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcCurveStyle::hasCurveWidth() const { return !data_->getArgument(2)->isNull(); } +IfcSizeSelect* IfcCurveStyle::CurveWidth() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcCurveStyle::setCurveWidth(IfcSizeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcCurveStyle::hasCurveColour() const { return !data_->getArgument(3)->isNull(); } +IfcColour* IfcCurveStyle::CurveColour() const { return (IfcColour*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcCurveStyle::setCurveColour(IfcColour* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcCurveStyle::declaration() const { return *IfcCurveStyle_type; } Type::Enum IfcCurveStyle::Class() { return Type::IfcCurveStyle; } -IfcCurveStyle::IfcCurveStyle(IfcAbstractEntity* e) : IfcPresentationStyle((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurveStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCurveStyle::IfcCurveStyle(boost::optional< std::string > v1_Name, IfcCurveFontOrScaledCurveFontSelect* v2_CurveFont, IfcSizeSelect* v3_CurveWidth, IfcColour* v4_CurveColour) : IfcPresentationStyle((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_CurveFont)); e->setArgument(2,(v3_CurveWidth)); e->setArgument(3,(v4_CurveColour)); entity = e; EntityBuffer::Add(this); } +IfcCurveStyle::IfcCurveStyle(IfcAbstractEntity* e) : IfcPresentationStyle((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurveStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCurveStyle::IfcCurveStyle(boost::optional< std::string > v1_Name, IfcCurveFontOrScaledCurveFontSelect* v2_CurveFont, IfcSizeSelect* v3_CurveWidth, IfcColour* v4_CurveColour) : IfcPresentationStyle((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_CurveFont)); e->setArgument(2,(v3_CurveWidth)); e->setArgument(3,(v4_CurveColour)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCurveStyleFont -bool IfcCurveStyleFont::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcCurveStyleFont::Name() const { return *entity->getArgument(0); } -void IfcCurveStyleFont::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcTemplatedEntityList< IfcCurveStyleFontPattern >::ptr IfcCurveStyleFont::PatternList() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcCurveStyleFont::setPatternList(IfcTemplatedEntityList< IfcCurveStyleFontPattern >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcCurveStyleFont::is(Type::Enum v) const { return v == Type::IfcCurveStyleFont; } -Type::Enum IfcCurveStyleFont::type() const { return Type::IfcCurveStyleFont; } +bool IfcCurveStyleFont::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcCurveStyleFont::Name() const { return *data_->getArgument(0); } +void IfcCurveStyleFont::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcTemplatedEntityList< IfcCurveStyleFontPattern >::ptr IfcCurveStyleFont::PatternList() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcCurveStyleFont::setPatternList(IfcTemplatedEntityList< IfcCurveStyleFontPattern >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } + + +const IfcParse::entity& IfcCurveStyleFont::declaration() const { return *IfcCurveStyleFont_type; } Type::Enum IfcCurveStyleFont::Class() { return Type::IfcCurveStyleFont; } -IfcCurveStyleFont::IfcCurveStyleFont(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCurveStyleFont)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCurveStyleFont::IfcCurveStyleFont(boost::optional< std::string > v1_Name, IfcTemplatedEntityList< IfcCurveStyleFontPattern >::ptr v2_PatternList) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_PatternList)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcCurveStyleFont::IfcCurveStyleFont(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCurveStyleFont)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCurveStyleFont::IfcCurveStyleFont(boost::optional< std::string > v1_Name, IfcTemplatedEntityList< IfcCurveStyleFontPattern >::ptr v2_PatternList) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_PatternList)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCurveStyleFontAndScaling -bool IfcCurveStyleFontAndScaling::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcCurveStyleFontAndScaling::Name() const { return *entity->getArgument(0); } -void IfcCurveStyleFontAndScaling::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcCurveStyleFontSelect* IfcCurveStyleFontAndScaling::CurveFont() const { return (IfcCurveStyleFontSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcCurveStyleFontAndScaling::setCurveFont(IfcCurveStyleFontSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcCurveStyleFontAndScaling::CurveFontScaling() const { return *entity->getArgument(2); } -void IfcCurveStyleFontAndScaling::setCurveFontScaling(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcCurveStyleFontAndScaling::is(Type::Enum v) const { return v == Type::IfcCurveStyleFontAndScaling; } -Type::Enum IfcCurveStyleFontAndScaling::type() const { return Type::IfcCurveStyleFontAndScaling; } +bool IfcCurveStyleFontAndScaling::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcCurveStyleFontAndScaling::Name() const { return *data_->getArgument(0); } +void IfcCurveStyleFontAndScaling::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcCurveStyleFontSelect* IfcCurveStyleFontAndScaling::CurveFont() const { return (IfcCurveStyleFontSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcCurveStyleFontAndScaling::setCurveFont(IfcCurveStyleFontSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcCurveStyleFontAndScaling::CurveFontScaling() const { return *data_->getArgument(2); } +void IfcCurveStyleFontAndScaling::setCurveFontScaling(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcCurveStyleFontAndScaling::declaration() const { return *IfcCurveStyleFontAndScaling_type; } Type::Enum IfcCurveStyleFontAndScaling::Class() { return Type::IfcCurveStyleFontAndScaling; } -IfcCurveStyleFontAndScaling::IfcCurveStyleFontAndScaling(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCurveStyleFontAndScaling)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCurveStyleFontAndScaling::IfcCurveStyleFontAndScaling(boost::optional< std::string > v1_Name, IfcCurveStyleFontSelect* v2_CurveFont, double v3_CurveFontScaling) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_CurveFont)); e->setArgument(2,(v3_CurveFontScaling)); entity = e; EntityBuffer::Add(this); } +IfcCurveStyleFontAndScaling::IfcCurveStyleFontAndScaling(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCurveStyleFontAndScaling)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCurveStyleFontAndScaling::IfcCurveStyleFontAndScaling(boost::optional< std::string > v1_Name, IfcCurveStyleFontSelect* v2_CurveFont, double v3_CurveFontScaling) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_CurveFont)); e->setArgument(2,(v3_CurveFontScaling)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCurveStyleFontPattern -double IfcCurveStyleFontPattern::VisibleSegmentLength() const { return *entity->getArgument(0); } -void IfcCurveStyleFontPattern::setVisibleSegmentLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcCurveStyleFontPattern::InvisibleSegmentLength() const { return *entity->getArgument(1); } -void IfcCurveStyleFontPattern::setInvisibleSegmentLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcCurveStyleFontPattern::is(Type::Enum v) const { return v == Type::IfcCurveStyleFontPattern; } -Type::Enum IfcCurveStyleFontPattern::type() const { return Type::IfcCurveStyleFontPattern; } +double IfcCurveStyleFontPattern::VisibleSegmentLength() const { return *data_->getArgument(0); } +void IfcCurveStyleFontPattern::setVisibleSegmentLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcCurveStyleFontPattern::InvisibleSegmentLength() const { return *data_->getArgument(1); } +void IfcCurveStyleFontPattern::setInvisibleSegmentLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcCurveStyleFontPattern::declaration() const { return *IfcCurveStyleFontPattern_type; } Type::Enum IfcCurveStyleFontPattern::Class() { return Type::IfcCurveStyleFontPattern; } -IfcCurveStyleFontPattern::IfcCurveStyleFontPattern(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCurveStyleFontPattern)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCurveStyleFontPattern::IfcCurveStyleFontPattern(double v1_VisibleSegmentLength, double v2_InvisibleSegmentLength) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_VisibleSegmentLength)); e->setArgument(1,(v2_InvisibleSegmentLength)); entity = e; EntityBuffer::Add(this); } +IfcCurveStyleFontPattern::IfcCurveStyleFontPattern(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCurveStyleFontPattern)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCurveStyleFontPattern::IfcCurveStyleFontPattern(double v1_VisibleSegmentLength, double v2_InvisibleSegmentLength) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_VisibleSegmentLength)); e->setArgument(1,(v2_InvisibleSegmentLength)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDamperType -IfcDamperTypeEnum::IfcDamperTypeEnum IfcDamperType::PredefinedType() const { return IfcDamperTypeEnum::FromString(*entity->getArgument(9)); } -void IfcDamperType::setPredefinedType(IfcDamperTypeEnum::IfcDamperTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcDamperTypeEnum::ToString(v)); } -bool IfcDamperType::is(Type::Enum v) const { return v == Type::IfcDamperType || IfcFlowControllerType::is(v); } -Type::Enum IfcDamperType::type() const { return Type::IfcDamperType; } +IfcDamperTypeEnum::IfcDamperTypeEnum IfcDamperType::PredefinedType() const { return IfcDamperTypeEnum::FromString(*data_->getArgument(9)); } +void IfcDamperType::setPredefinedType(IfcDamperTypeEnum::IfcDamperTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcDamperTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcDamperType::declaration() const { return *IfcDamperType_type; } Type::Enum IfcDamperType::Class() { return Type::IfcDamperType; } -IfcDamperType::IfcDamperType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDamperType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDamperType::IfcDamperType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDamperTypeEnum::IfcDamperTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcDamperTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcDamperType::IfcDamperType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDamperType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDamperType::IfcDamperType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDamperTypeEnum::IfcDamperTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcDamperTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDateAndTime -IfcCalendarDate* IfcDateAndTime::DateComponent() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcDateAndTime::setDateComponent(IfcCalendarDate* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcLocalTime* IfcDateAndTime::TimeComponent() const { return (IfcLocalTime*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcDateAndTime::setTimeComponent(IfcLocalTime* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcDateAndTime::is(Type::Enum v) const { return v == Type::IfcDateAndTime; } -Type::Enum IfcDateAndTime::type() const { return Type::IfcDateAndTime; } +IfcCalendarDate* IfcDateAndTime::DateComponent() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcDateAndTime::setDateComponent(IfcCalendarDate* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcLocalTime* IfcDateAndTime::TimeComponent() const { return (IfcLocalTime*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcDateAndTime::setTimeComponent(IfcLocalTime* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcDateAndTime::declaration() const { return *IfcDateAndTime_type; } Type::Enum IfcDateAndTime::Class() { return Type::IfcDateAndTime; } -IfcDateAndTime::IfcDateAndTime(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDateAndTime)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDateAndTime::IfcDateAndTime(IfcCalendarDate* v1_DateComponent, IfcLocalTime* v2_TimeComponent) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DateComponent)); e->setArgument(1,(v2_TimeComponent)); entity = e; EntityBuffer::Add(this); } +IfcDateAndTime::IfcDateAndTime(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDateAndTime)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDateAndTime::IfcDateAndTime(IfcCalendarDate* v1_DateComponent, IfcLocalTime* v2_TimeComponent) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DateComponent)); e->setArgument(1,(v2_TimeComponent)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDefinedSymbol -IfcDefinedSymbolSelect* IfcDefinedSymbol::Definition() const { return (IfcDefinedSymbolSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcDefinedSymbol::setDefinition(IfcDefinedSymbolSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcCartesianTransformationOperator2D* IfcDefinedSymbol::Target() const { return (IfcCartesianTransformationOperator2D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcDefinedSymbol::setTarget(IfcCartesianTransformationOperator2D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcDefinedSymbol::is(Type::Enum v) const { return v == Type::IfcDefinedSymbol || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcDefinedSymbol::type() const { return Type::IfcDefinedSymbol; } +IfcDefinedSymbolSelect* IfcDefinedSymbol::Definition() const { return (IfcDefinedSymbolSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcDefinedSymbol::setDefinition(IfcDefinedSymbolSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcCartesianTransformationOperator2D* IfcDefinedSymbol::Target() const { return (IfcCartesianTransformationOperator2D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcDefinedSymbol::setTarget(IfcCartesianTransformationOperator2D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcDefinedSymbol::declaration() const { return *IfcDefinedSymbol_type; } Type::Enum IfcDefinedSymbol::Class() { return Type::IfcDefinedSymbol; } -IfcDefinedSymbol::IfcDefinedSymbol(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDefinedSymbol)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDefinedSymbol::IfcDefinedSymbol(IfcDefinedSymbolSelect* v1_Definition, IfcCartesianTransformationOperator2D* v2_Target) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Definition)); e->setArgument(1,(v2_Target)); entity = e; EntityBuffer::Add(this); } +IfcDefinedSymbol::IfcDefinedSymbol(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDefinedSymbol)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDefinedSymbol::IfcDefinedSymbol(IfcDefinedSymbolSelect* v1_Definition, IfcCartesianTransformationOperator2D* v2_Target) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Definition)); e->setArgument(1,(v2_Target)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDerivedProfileDef -IfcProfileDef* IfcDerivedProfileDef::ParentProfile() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcDerivedProfileDef::setParentProfile(IfcProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcCartesianTransformationOperator2D* IfcDerivedProfileDef::Operator() const { return (IfcCartesianTransformationOperator2D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcDerivedProfileDef::setOperator(IfcCartesianTransformationOperator2D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcDerivedProfileDef::hasLabel() const { return !entity->getArgument(4)->isNull(); } -std::string IfcDerivedProfileDef::Label() const { return *entity->getArgument(4); } -void IfcDerivedProfileDef::setLabel(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcDerivedProfileDef::is(Type::Enum v) const { return v == Type::IfcDerivedProfileDef || IfcProfileDef::is(v); } -Type::Enum IfcDerivedProfileDef::type() const { return Type::IfcDerivedProfileDef; } +IfcProfileDef* IfcDerivedProfileDef::ParentProfile() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcDerivedProfileDef::setParentProfile(IfcProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcCartesianTransformationOperator2D* IfcDerivedProfileDef::Operator() const { return (IfcCartesianTransformationOperator2D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcDerivedProfileDef::setOperator(IfcCartesianTransformationOperator2D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcDerivedProfileDef::hasLabel() const { return !data_->getArgument(4)->isNull(); } +std::string IfcDerivedProfileDef::Label() const { return *data_->getArgument(4); } +void IfcDerivedProfileDef::setLabel(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcDerivedProfileDef::declaration() const { return *IfcDerivedProfileDef_type; } Type::Enum IfcDerivedProfileDef::Class() { return Type::IfcDerivedProfileDef; } -IfcDerivedProfileDef::IfcDerivedProfileDef(IfcAbstractEntity* e) : IfcProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDerivedProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDerivedProfileDef::IfcDerivedProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcProfileDef* v3_ParentProfile, IfcCartesianTransformationOperator2D* v4_Operator, boost::optional< std::string > v5_Label) : IfcProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_ParentProfile)); e->setArgument(3,(v4_Operator)); if (v5_Label) { e->setArgument(4,(*v5_Label)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcDerivedProfileDef::IfcDerivedProfileDef(IfcAbstractEntity* e) : IfcProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDerivedProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDerivedProfileDef::IfcDerivedProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcProfileDef* v3_ParentProfile, IfcCartesianTransformationOperator2D* v4_Operator, boost::optional< std::string > v5_Label) : IfcProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_ParentProfile)); e->setArgument(3,(v4_Operator)); if (v5_Label) { e->setArgument(4,(*v5_Label)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDerivedUnit -IfcTemplatedEntityList< IfcDerivedUnitElement >::ptr IfcDerivedUnit::Elements() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcDerivedUnit::setElements(IfcTemplatedEntityList< IfcDerivedUnitElement >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -IfcDerivedUnitEnum::IfcDerivedUnitEnum IfcDerivedUnit::UnitType() const { return IfcDerivedUnitEnum::FromString(*entity->getArgument(1)); } -void IfcDerivedUnit::setUnitType(IfcDerivedUnitEnum::IfcDerivedUnitEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v,IfcDerivedUnitEnum::ToString(v)); } -bool IfcDerivedUnit::hasUserDefinedType() const { return !entity->getArgument(2)->isNull(); } -std::string IfcDerivedUnit::UserDefinedType() const { return *entity->getArgument(2); } -void IfcDerivedUnit::setUserDefinedType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcDerivedUnit::is(Type::Enum v) const { return v == Type::IfcDerivedUnit; } -Type::Enum IfcDerivedUnit::type() const { return Type::IfcDerivedUnit; } +IfcTemplatedEntityList< IfcDerivedUnitElement >::ptr IfcDerivedUnit::Elements() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcDerivedUnit::setElements(IfcTemplatedEntityList< IfcDerivedUnitElement >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } +IfcDerivedUnitEnum::IfcDerivedUnitEnum IfcDerivedUnit::UnitType() const { return IfcDerivedUnitEnum::FromString(*data_->getArgument(1)); } +void IfcDerivedUnit::setUnitType(IfcDerivedUnitEnum::IfcDerivedUnitEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v,IfcDerivedUnitEnum::ToString(v)); } +bool IfcDerivedUnit::hasUserDefinedType() const { return !data_->getArgument(2)->isNull(); } +std::string IfcDerivedUnit::UserDefinedType() const { return *data_->getArgument(2); } +void IfcDerivedUnit::setUserDefinedType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcDerivedUnit::declaration() const { return *IfcDerivedUnit_type; } Type::Enum IfcDerivedUnit::Class() { return Type::IfcDerivedUnit; } -IfcDerivedUnit::IfcDerivedUnit(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDerivedUnit)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDerivedUnit::IfcDerivedUnit(IfcTemplatedEntityList< IfcDerivedUnitElement >::ptr v1_Elements, IfcDerivedUnitEnum::IfcDerivedUnitEnum v2_UnitType, boost::optional< std::string > v3_UserDefinedType) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Elements)->generalize()); e->setArgument(1,v2_UnitType,IfcDerivedUnitEnum::ToString(v2_UnitType)); if (v3_UserDefinedType) { e->setArgument(2,(*v3_UserDefinedType)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcDerivedUnit::IfcDerivedUnit(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDerivedUnit)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDerivedUnit::IfcDerivedUnit(IfcTemplatedEntityList< IfcDerivedUnitElement >::ptr v1_Elements, IfcDerivedUnitEnum::IfcDerivedUnitEnum v2_UnitType, boost::optional< std::string > v3_UserDefinedType) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Elements)->generalize()); e->setArgument(1,v2_UnitType,IfcDerivedUnitEnum::ToString(v2_UnitType)); if (v3_UserDefinedType) { e->setArgument(2,(*v3_UserDefinedType)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDerivedUnitElement -IfcNamedUnit* IfcDerivedUnitElement::Unit() const { return (IfcNamedUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcDerivedUnitElement::setUnit(IfcNamedUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -int IfcDerivedUnitElement::Exponent() const { return *entity->getArgument(1); } -void IfcDerivedUnitElement::setExponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcDerivedUnitElement::is(Type::Enum v) const { return v == Type::IfcDerivedUnitElement; } -Type::Enum IfcDerivedUnitElement::type() const { return Type::IfcDerivedUnitElement; } +IfcNamedUnit* IfcDerivedUnitElement::Unit() const { return (IfcNamedUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcDerivedUnitElement::setUnit(IfcNamedUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +int IfcDerivedUnitElement::Exponent() const { return *data_->getArgument(1); } +void IfcDerivedUnitElement::setExponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcDerivedUnitElement::declaration() const { return *IfcDerivedUnitElement_type; } Type::Enum IfcDerivedUnitElement::Class() { return Type::IfcDerivedUnitElement; } -IfcDerivedUnitElement::IfcDerivedUnitElement(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDerivedUnitElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDerivedUnitElement::IfcDerivedUnitElement(IfcNamedUnit* v1_Unit, int v2_Exponent) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Unit)); e->setArgument(1,(v2_Exponent)); entity = e; EntityBuffer::Add(this); } +IfcDerivedUnitElement::IfcDerivedUnitElement(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDerivedUnitElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDerivedUnitElement::IfcDerivedUnitElement(IfcNamedUnit* v1_Unit, int v2_Exponent) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Unit)); e->setArgument(1,(v2_Exponent)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDiameterDimension -bool IfcDiameterDimension::is(Type::Enum v) const { return v == Type::IfcDiameterDimension || IfcDimensionCurveDirectedCallout::is(v); } -Type::Enum IfcDiameterDimension::type() const { return Type::IfcDiameterDimension; } + + +const IfcParse::entity& IfcDiameterDimension::declaration() const { return *IfcDiameterDimension_type; } Type::Enum IfcDiameterDimension::Class() { return Type::IfcDiameterDimension; } -IfcDiameterDimension::IfcDiameterDimension(IfcAbstractEntity* e) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDiameterDimension)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDiameterDimension::IfcDiameterDimension(IfcEntityList::ptr v1_Contents) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); entity = e; EntityBuffer::Add(this); } +IfcDiameterDimension::IfcDiameterDimension(IfcAbstractEntity* e) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDiameterDimension)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDiameterDimension::IfcDiameterDimension(IfcEntityList::ptr v1_Contents) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDimensionCalloutRelationship -bool IfcDimensionCalloutRelationship::is(Type::Enum v) const { return v == Type::IfcDimensionCalloutRelationship || IfcDraughtingCalloutRelationship::is(v); } -Type::Enum IfcDimensionCalloutRelationship::type() const { return Type::IfcDimensionCalloutRelationship; } + + +const IfcParse::entity& IfcDimensionCalloutRelationship::declaration() const { return *IfcDimensionCalloutRelationship_type; } Type::Enum IfcDimensionCalloutRelationship::Class() { return Type::IfcDimensionCalloutRelationship; } -IfcDimensionCalloutRelationship::IfcDimensionCalloutRelationship(IfcAbstractEntity* e) : IfcDraughtingCalloutRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDimensionCalloutRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDimensionCalloutRelationship::IfcDimensionCalloutRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDraughtingCallout* v3_RelatingDraughtingCallout, IfcDraughtingCallout* v4_RelatedDraughtingCallout) : IfcDraughtingCalloutRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingDraughtingCallout)); e->setArgument(3,(v4_RelatedDraughtingCallout)); entity = e; EntityBuffer::Add(this); } +IfcDimensionCalloutRelationship::IfcDimensionCalloutRelationship(IfcAbstractEntity* e) : IfcDraughtingCalloutRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDimensionCalloutRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDimensionCalloutRelationship::IfcDimensionCalloutRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDraughtingCallout* v3_RelatingDraughtingCallout, IfcDraughtingCallout* v4_RelatedDraughtingCallout) : IfcDraughtingCalloutRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingDraughtingCallout)); e->setArgument(3,(v4_RelatedDraughtingCallout)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDimensionCurve -IfcTerminatorSymbol::list::ptr IfcDimensionCurve::AnnotatedBySymbols() const { return entity->getInverse(Type::IfcTerminatorSymbol, 3)->as(); } -bool IfcDimensionCurve::is(Type::Enum v) const { return v == Type::IfcDimensionCurve || IfcAnnotationCurveOccurrence::is(v); } -Type::Enum IfcDimensionCurve::type() const { return Type::IfcDimensionCurve; } + +IfcTerminatorSymbol::list::ptr IfcDimensionCurve::AnnotatedBySymbols() const { return data_->getInverse(Type::IfcTerminatorSymbol, 3)->as(); } + +const IfcParse::entity& IfcDimensionCurve::declaration() const { return *IfcDimensionCurve_type; } Type::Enum IfcDimensionCurve::Class() { return Type::IfcDimensionCurve; } -IfcDimensionCurve::IfcDimensionCurve(IfcAbstractEntity* e) : IfcAnnotationCurveOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDimensionCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDimensionCurve::IfcDimensionCurve(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationCurveOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcDimensionCurve::IfcDimensionCurve(IfcAbstractEntity* e) : IfcAnnotationCurveOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDimensionCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDimensionCurve::IfcDimensionCurve(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationCurveOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDimensionCurveDirectedCallout -bool IfcDimensionCurveDirectedCallout::is(Type::Enum v) const { return v == Type::IfcDimensionCurveDirectedCallout || IfcDraughtingCallout::is(v); } -Type::Enum IfcDimensionCurveDirectedCallout::type() const { return Type::IfcDimensionCurveDirectedCallout; } + + +const IfcParse::entity& IfcDimensionCurveDirectedCallout::declaration() const { return *IfcDimensionCurveDirectedCallout_type; } Type::Enum IfcDimensionCurveDirectedCallout::Class() { return Type::IfcDimensionCurveDirectedCallout; } -IfcDimensionCurveDirectedCallout::IfcDimensionCurveDirectedCallout(IfcAbstractEntity* e) : IfcDraughtingCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDimensionCurveDirectedCallout)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDimensionCurveDirectedCallout::IfcDimensionCurveDirectedCallout(IfcEntityList::ptr v1_Contents) : IfcDraughtingCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); entity = e; EntityBuffer::Add(this); } +IfcDimensionCurveDirectedCallout::IfcDimensionCurveDirectedCallout(IfcAbstractEntity* e) : IfcDraughtingCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDimensionCurveDirectedCallout)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDimensionCurveDirectedCallout::IfcDimensionCurveDirectedCallout(IfcEntityList::ptr v1_Contents) : IfcDraughtingCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDimensionCurveTerminator -IfcDimensionExtentUsage::IfcDimensionExtentUsage IfcDimensionCurveTerminator::Role() const { return IfcDimensionExtentUsage::FromString(*entity->getArgument(4)); } -void IfcDimensionCurveTerminator::setRole(IfcDimensionExtentUsage::IfcDimensionExtentUsage v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcDimensionExtentUsage::ToString(v)); } -bool IfcDimensionCurveTerminator::is(Type::Enum v) const { return v == Type::IfcDimensionCurveTerminator || IfcTerminatorSymbol::is(v); } -Type::Enum IfcDimensionCurveTerminator::type() const { return Type::IfcDimensionCurveTerminator; } +IfcDimensionExtentUsage::IfcDimensionExtentUsage IfcDimensionCurveTerminator::Role() const { return IfcDimensionExtentUsage::FromString(*data_->getArgument(4)); } +void IfcDimensionCurveTerminator::setRole(IfcDimensionExtentUsage::IfcDimensionExtentUsage v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcDimensionExtentUsage::ToString(v)); } + + +const IfcParse::entity& IfcDimensionCurveTerminator::declaration() const { return *IfcDimensionCurveTerminator_type; } Type::Enum IfcDimensionCurveTerminator::Class() { return Type::IfcDimensionCurveTerminator; } -IfcDimensionCurveTerminator::IfcDimensionCurveTerminator(IfcAbstractEntity* e) : IfcTerminatorSymbol((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDimensionCurveTerminator)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDimensionCurveTerminator::IfcDimensionCurveTerminator(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, IfcAnnotationCurveOccurrence* v4_AnnotatedCurve, IfcDimensionExtentUsage::IfcDimensionExtentUsage v5_Role) : IfcTerminatorSymbol((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } e->setArgument(3,(v4_AnnotatedCurve)); e->setArgument(4,v5_Role,IfcDimensionExtentUsage::ToString(v5_Role)); entity = e; EntityBuffer::Add(this); } +IfcDimensionCurveTerminator::IfcDimensionCurveTerminator(IfcAbstractEntity* e) : IfcTerminatorSymbol((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDimensionCurveTerminator)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDimensionCurveTerminator::IfcDimensionCurveTerminator(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, IfcAnnotationCurveOccurrence* v4_AnnotatedCurve, IfcDimensionExtentUsage::IfcDimensionExtentUsage v5_Role) : IfcTerminatorSymbol((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } e->setArgument(3,(v4_AnnotatedCurve)); e->setArgument(4,v5_Role,IfcDimensionExtentUsage::ToString(v5_Role)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDimensionPair -bool IfcDimensionPair::is(Type::Enum v) const { return v == Type::IfcDimensionPair || IfcDraughtingCalloutRelationship::is(v); } -Type::Enum IfcDimensionPair::type() const { return Type::IfcDimensionPair; } + + +const IfcParse::entity& IfcDimensionPair::declaration() const { return *IfcDimensionPair_type; } Type::Enum IfcDimensionPair::Class() { return Type::IfcDimensionPair; } -IfcDimensionPair::IfcDimensionPair(IfcAbstractEntity* e) : IfcDraughtingCalloutRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDimensionPair)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDimensionPair::IfcDimensionPair(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDraughtingCallout* v3_RelatingDraughtingCallout, IfcDraughtingCallout* v4_RelatedDraughtingCallout) : IfcDraughtingCalloutRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingDraughtingCallout)); e->setArgument(3,(v4_RelatedDraughtingCallout)); entity = e; EntityBuffer::Add(this); } +IfcDimensionPair::IfcDimensionPair(IfcAbstractEntity* e) : IfcDraughtingCalloutRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDimensionPair)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDimensionPair::IfcDimensionPair(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDraughtingCallout* v3_RelatingDraughtingCallout, IfcDraughtingCallout* v4_RelatedDraughtingCallout) : IfcDraughtingCalloutRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingDraughtingCallout)); e->setArgument(3,(v4_RelatedDraughtingCallout)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDimensionalExponents -int IfcDimensionalExponents::LengthExponent() const { return *entity->getArgument(0); } -void IfcDimensionalExponents::setLengthExponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -int IfcDimensionalExponents::MassExponent() const { return *entity->getArgument(1); } -void IfcDimensionalExponents::setMassExponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -int IfcDimensionalExponents::TimeExponent() const { return *entity->getArgument(2); } -void IfcDimensionalExponents::setTimeExponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -int IfcDimensionalExponents::ElectricCurrentExponent() const { return *entity->getArgument(3); } -void IfcDimensionalExponents::setElectricCurrentExponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -int IfcDimensionalExponents::ThermodynamicTemperatureExponent() const { return *entity->getArgument(4); } -void IfcDimensionalExponents::setThermodynamicTemperatureExponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -int IfcDimensionalExponents::AmountOfSubstanceExponent() const { return *entity->getArgument(5); } -void IfcDimensionalExponents::setAmountOfSubstanceExponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -int IfcDimensionalExponents::LuminousIntensityExponent() const { return *entity->getArgument(6); } -void IfcDimensionalExponents::setLuminousIntensityExponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcDimensionalExponents::is(Type::Enum v) const { return v == Type::IfcDimensionalExponents; } -Type::Enum IfcDimensionalExponents::type() const { return Type::IfcDimensionalExponents; } +int IfcDimensionalExponents::LengthExponent() const { return *data_->getArgument(0); } +void IfcDimensionalExponents::setLengthExponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +int IfcDimensionalExponents::MassExponent() const { return *data_->getArgument(1); } +void IfcDimensionalExponents::setMassExponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +int IfcDimensionalExponents::TimeExponent() const { return *data_->getArgument(2); } +void IfcDimensionalExponents::setTimeExponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +int IfcDimensionalExponents::ElectricCurrentExponent() const { return *data_->getArgument(3); } +void IfcDimensionalExponents::setElectricCurrentExponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +int IfcDimensionalExponents::ThermodynamicTemperatureExponent() const { return *data_->getArgument(4); } +void IfcDimensionalExponents::setThermodynamicTemperatureExponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +int IfcDimensionalExponents::AmountOfSubstanceExponent() const { return *data_->getArgument(5); } +void IfcDimensionalExponents::setAmountOfSubstanceExponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +int IfcDimensionalExponents::LuminousIntensityExponent() const { return *data_->getArgument(6); } +void IfcDimensionalExponents::setLuminousIntensityExponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcDimensionalExponents::declaration() const { return *IfcDimensionalExponents_type; } Type::Enum IfcDimensionalExponents::Class() { return Type::IfcDimensionalExponents; } -IfcDimensionalExponents::IfcDimensionalExponents(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDimensionalExponents)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDimensionalExponents::IfcDimensionalExponents(int v1_LengthExponent, int v2_MassExponent, int v3_TimeExponent, int v4_ElectricCurrentExponent, int v5_ThermodynamicTemperatureExponent, int v6_AmountOfSubstanceExponent, int v7_LuminousIntensityExponent) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_LengthExponent)); e->setArgument(1,(v2_MassExponent)); e->setArgument(2,(v3_TimeExponent)); e->setArgument(3,(v4_ElectricCurrentExponent)); e->setArgument(4,(v5_ThermodynamicTemperatureExponent)); e->setArgument(5,(v6_AmountOfSubstanceExponent)); e->setArgument(6,(v7_LuminousIntensityExponent)); entity = e; EntityBuffer::Add(this); } +IfcDimensionalExponents::IfcDimensionalExponents(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDimensionalExponents)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDimensionalExponents::IfcDimensionalExponents(int v1_LengthExponent, int v2_MassExponent, int v3_TimeExponent, int v4_ElectricCurrentExponent, int v5_ThermodynamicTemperatureExponent, int v6_AmountOfSubstanceExponent, int v7_LuminousIntensityExponent) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_LengthExponent)); e->setArgument(1,(v2_MassExponent)); e->setArgument(2,(v3_TimeExponent)); e->setArgument(3,(v4_ElectricCurrentExponent)); e->setArgument(4,(v5_ThermodynamicTemperatureExponent)); e->setArgument(5,(v6_AmountOfSubstanceExponent)); e->setArgument(6,(v7_LuminousIntensityExponent)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDirection -std::vector< double > /*[2:3]*/ IfcDirection::DirectionRatios() const { return *entity->getArgument(0); } -void IfcDirection::setDirectionRatios(std::vector< double > /*[2:3]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcDirection::is(Type::Enum v) const { return v == Type::IfcDirection || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcDirection::type() const { return Type::IfcDirection; } +std::vector< double > /*[2:3]*/ IfcDirection::DirectionRatios() const { return *data_->getArgument(0); } +void IfcDirection::setDirectionRatios(std::vector< double > /*[2:3]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcDirection::declaration() const { return *IfcDirection_type; } Type::Enum IfcDirection::Class() { return Type::IfcDirection; } -IfcDirection::IfcDirection(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDirection)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDirection::IfcDirection(std::vector< double > /*[2:3]*/ v1_DirectionRatios) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DirectionRatios)); entity = e; EntityBuffer::Add(this); } +IfcDirection::IfcDirection(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDirection)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDirection::IfcDirection(std::vector< double > /*[2:3]*/ v1_DirectionRatios) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DirectionRatios)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDiscreteAccessory -bool IfcDiscreteAccessory::is(Type::Enum v) const { return v == Type::IfcDiscreteAccessory || IfcElementComponent::is(v); } -Type::Enum IfcDiscreteAccessory::type() const { return Type::IfcDiscreteAccessory; } + + +const IfcParse::entity& IfcDiscreteAccessory::declaration() const { return *IfcDiscreteAccessory_type; } Type::Enum IfcDiscreteAccessory::Class() { return Type::IfcDiscreteAccessory; } -IfcDiscreteAccessory::IfcDiscreteAccessory(IfcAbstractEntity* e) : IfcElementComponent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDiscreteAccessory)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDiscreteAccessory::IfcDiscreteAccessory(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElementComponent((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcDiscreteAccessory::IfcDiscreteAccessory(IfcAbstractEntity* e) : IfcElementComponent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDiscreteAccessory)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDiscreteAccessory::IfcDiscreteAccessory(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElementComponent((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDiscreteAccessoryType -bool IfcDiscreteAccessoryType::is(Type::Enum v) const { return v == Type::IfcDiscreteAccessoryType || IfcElementComponentType::is(v); } -Type::Enum IfcDiscreteAccessoryType::type() const { return Type::IfcDiscreteAccessoryType; } + + +const IfcParse::entity& IfcDiscreteAccessoryType::declaration() const { return *IfcDiscreteAccessoryType_type; } Type::Enum IfcDiscreteAccessoryType::Class() { return Type::IfcDiscreteAccessoryType; } -IfcDiscreteAccessoryType::IfcDiscreteAccessoryType(IfcAbstractEntity* e) : IfcElementComponentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDiscreteAccessoryType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDiscreteAccessoryType::IfcDiscreteAccessoryType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementComponentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcDiscreteAccessoryType::IfcDiscreteAccessoryType(IfcAbstractEntity* e) : IfcElementComponentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDiscreteAccessoryType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDiscreteAccessoryType::IfcDiscreteAccessoryType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementComponentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionChamberElement -bool IfcDistributionChamberElement::is(Type::Enum v) const { return v == Type::IfcDistributionChamberElement || IfcDistributionFlowElement::is(v); } -Type::Enum IfcDistributionChamberElement::type() const { return Type::IfcDistributionChamberElement; } + + +const IfcParse::entity& IfcDistributionChamberElement::declaration() const { return *IfcDistributionChamberElement_type; } Type::Enum IfcDistributionChamberElement::Class() { return Type::IfcDistributionChamberElement; } -IfcDistributionChamberElement::IfcDistributionChamberElement(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionChamberElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDistributionChamberElement::IfcDistributionChamberElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcDistributionChamberElement::IfcDistributionChamberElement(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionChamberElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDistributionChamberElement::IfcDistributionChamberElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionChamberElementType -IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum IfcDistributionChamberElementType::PredefinedType() const { return IfcDistributionChamberElementTypeEnum::FromString(*entity->getArgument(9)); } -void IfcDistributionChamberElementType::setPredefinedType(IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcDistributionChamberElementTypeEnum::ToString(v)); } -bool IfcDistributionChamberElementType::is(Type::Enum v) const { return v == Type::IfcDistributionChamberElementType || IfcDistributionFlowElementType::is(v); } -Type::Enum IfcDistributionChamberElementType::type() const { return Type::IfcDistributionChamberElementType; } +IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum IfcDistributionChamberElementType::PredefinedType() const { return IfcDistributionChamberElementTypeEnum::FromString(*data_->getArgument(9)); } +void IfcDistributionChamberElementType::setPredefinedType(IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcDistributionChamberElementTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcDistributionChamberElementType::declaration() const { return *IfcDistributionChamberElementType_type; } Type::Enum IfcDistributionChamberElementType::Class() { return Type::IfcDistributionChamberElementType; } -IfcDistributionChamberElementType::IfcDistributionChamberElementType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionChamberElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDistributionChamberElementType::IfcDistributionChamberElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum v10_PredefinedType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcDistributionChamberElementTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcDistributionChamberElementType::IfcDistributionChamberElementType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionChamberElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDistributionChamberElementType::IfcDistributionChamberElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum v10_PredefinedType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcDistributionChamberElementTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionControlElement -bool IfcDistributionControlElement::hasControlElementId() const { return !entity->getArgument(8)->isNull(); } -std::string IfcDistributionControlElement::ControlElementId() const { return *entity->getArgument(8); } -void IfcDistributionControlElement::setControlElementId(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -IfcRelFlowControlElements::list::ptr IfcDistributionControlElement::AssignedToFlowElement() const { return entity->getInverse(Type::IfcRelFlowControlElements, 4)->as(); } -bool IfcDistributionControlElement::is(Type::Enum v) const { return v == Type::IfcDistributionControlElement || IfcDistributionElement::is(v); } -Type::Enum IfcDistributionControlElement::type() const { return Type::IfcDistributionControlElement; } +bool IfcDistributionControlElement::hasControlElementId() const { return !data_->getArgument(8)->isNull(); } +std::string IfcDistributionControlElement::ControlElementId() const { return *data_->getArgument(8); } +void IfcDistributionControlElement::setControlElementId(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + +IfcRelFlowControlElements::list::ptr IfcDistributionControlElement::AssignedToFlowElement() const { return data_->getInverse(Type::IfcRelFlowControlElements, 4)->as(); } + +const IfcParse::entity& IfcDistributionControlElement::declaration() const { return *IfcDistributionControlElement_type; } Type::Enum IfcDistributionControlElement::Class() { return Type::IfcDistributionControlElement; } -IfcDistributionControlElement::IfcDistributionControlElement(IfcAbstractEntity* e) : IfcDistributionElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionControlElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDistributionControlElement::IfcDistributionControlElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ControlElementId) : IfcDistributionElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ControlElementId) { e->setArgument(8,(*v9_ControlElementId)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcDistributionControlElement::IfcDistributionControlElement(IfcAbstractEntity* e) : IfcDistributionElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionControlElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDistributionControlElement::IfcDistributionControlElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ControlElementId) : IfcDistributionElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ControlElementId) { e->setArgument(8,(*v9_ControlElementId)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionControlElementType -bool IfcDistributionControlElementType::is(Type::Enum v) const { return v == Type::IfcDistributionControlElementType || IfcDistributionElementType::is(v); } -Type::Enum IfcDistributionControlElementType::type() const { return Type::IfcDistributionControlElementType; } + + +const IfcParse::entity& IfcDistributionControlElementType::declaration() const { return *IfcDistributionControlElementType_type; } Type::Enum IfcDistributionControlElementType::Class() { return Type::IfcDistributionControlElementType; } -IfcDistributionControlElementType::IfcDistributionControlElementType(IfcAbstractEntity* e) : IfcDistributionElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionControlElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDistributionControlElementType::IfcDistributionControlElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcDistributionControlElementType::IfcDistributionControlElementType(IfcAbstractEntity* e) : IfcDistributionElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionControlElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDistributionControlElementType::IfcDistributionControlElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionElement -bool IfcDistributionElement::is(Type::Enum v) const { return v == Type::IfcDistributionElement || IfcElement::is(v); } -Type::Enum IfcDistributionElement::type() const { return Type::IfcDistributionElement; } + + +const IfcParse::entity& IfcDistributionElement::declaration() const { return *IfcDistributionElement_type; } Type::Enum IfcDistributionElement::Class() { return Type::IfcDistributionElement; } -IfcDistributionElement::IfcDistributionElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDistributionElement::IfcDistributionElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcDistributionElement::IfcDistributionElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDistributionElement::IfcDistributionElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionElementType -bool IfcDistributionElementType::is(Type::Enum v) const { return v == Type::IfcDistributionElementType || IfcElementType::is(v); } -Type::Enum IfcDistributionElementType::type() const { return Type::IfcDistributionElementType; } + + +const IfcParse::entity& IfcDistributionElementType::declaration() const { return *IfcDistributionElementType_type; } Type::Enum IfcDistributionElementType::Class() { return Type::IfcDistributionElementType; } -IfcDistributionElementType::IfcDistributionElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDistributionElementType::IfcDistributionElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcDistributionElementType::IfcDistributionElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDistributionElementType::IfcDistributionElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionFlowElement -IfcRelFlowControlElements::list::ptr IfcDistributionFlowElement::HasControlElements() const { return entity->getInverse(Type::IfcRelFlowControlElements, 5)->as(); } -bool IfcDistributionFlowElement::is(Type::Enum v) const { return v == Type::IfcDistributionFlowElement || IfcDistributionElement::is(v); } -Type::Enum IfcDistributionFlowElement::type() const { return Type::IfcDistributionFlowElement; } + +IfcRelFlowControlElements::list::ptr IfcDistributionFlowElement::HasControlElements() const { return data_->getInverse(Type::IfcRelFlowControlElements, 5)->as(); } + +const IfcParse::entity& IfcDistributionFlowElement::declaration() const { return *IfcDistributionFlowElement_type; } Type::Enum IfcDistributionFlowElement::Class() { return Type::IfcDistributionFlowElement; } -IfcDistributionFlowElement::IfcDistributionFlowElement(IfcAbstractEntity* e) : IfcDistributionElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionFlowElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDistributionFlowElement::IfcDistributionFlowElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcDistributionFlowElement::IfcDistributionFlowElement(IfcAbstractEntity* e) : IfcDistributionElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionFlowElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDistributionFlowElement::IfcDistributionFlowElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionFlowElementType -bool IfcDistributionFlowElementType::is(Type::Enum v) const { return v == Type::IfcDistributionFlowElementType || IfcDistributionElementType::is(v); } -Type::Enum IfcDistributionFlowElementType::type() const { return Type::IfcDistributionFlowElementType; } + + +const IfcParse::entity& IfcDistributionFlowElementType::declaration() const { return *IfcDistributionFlowElementType_type; } Type::Enum IfcDistributionFlowElementType::Class() { return Type::IfcDistributionFlowElementType; } -IfcDistributionFlowElementType::IfcDistributionFlowElementType(IfcAbstractEntity* e) : IfcDistributionElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionFlowElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDistributionFlowElementType::IfcDistributionFlowElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcDistributionFlowElementType::IfcDistributionFlowElementType(IfcAbstractEntity* e) : IfcDistributionElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionFlowElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDistributionFlowElementType::IfcDistributionFlowElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionPort -bool IfcDistributionPort::hasFlowDirection() const { return !entity->getArgument(7)->isNull(); } -IfcFlowDirectionEnum::IfcFlowDirectionEnum IfcDistributionPort::FlowDirection() const { return IfcFlowDirectionEnum::FromString(*entity->getArgument(7)); } -void IfcDistributionPort::setFlowDirection(IfcFlowDirectionEnum::IfcFlowDirectionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcFlowDirectionEnum::ToString(v)); } -bool IfcDistributionPort::is(Type::Enum v) const { return v == Type::IfcDistributionPort || IfcPort::is(v); } -Type::Enum IfcDistributionPort::type() const { return Type::IfcDistributionPort; } +bool IfcDistributionPort::hasFlowDirection() const { return !data_->getArgument(7)->isNull(); } +IfcFlowDirectionEnum::IfcFlowDirectionEnum IfcDistributionPort::FlowDirection() const { return IfcFlowDirectionEnum::FromString(*data_->getArgument(7)); } +void IfcDistributionPort::setFlowDirection(IfcFlowDirectionEnum::IfcFlowDirectionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcFlowDirectionEnum::ToString(v)); } + + +const IfcParse::entity& IfcDistributionPort::declaration() const { return *IfcDistributionPort_type; } Type::Enum IfcDistributionPort::Class() { return Type::IfcDistributionPort; } -IfcDistributionPort::IfcDistributionPort(IfcAbstractEntity* e) : IfcPort((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionPort)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDistributionPort::IfcDistributionPort(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< IfcFlowDirectionEnum::IfcFlowDirectionEnum > v8_FlowDirection) : IfcPort((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_FlowDirection) { e->setArgument(7,*v8_FlowDirection,IfcFlowDirectionEnum::ToString(*v8_FlowDirection)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcDistributionPort::IfcDistributionPort(IfcAbstractEntity* e) : IfcPort((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionPort)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDistributionPort::IfcDistributionPort(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< IfcFlowDirectionEnum::IfcFlowDirectionEnum > v8_FlowDirection) : IfcPort((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_FlowDirection) { e->setArgument(7,*v8_FlowDirection,IfcFlowDirectionEnum::ToString(*v8_FlowDirection)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDocumentElectronicFormat -bool IfcDocumentElectronicFormat::hasFileExtension() const { return !entity->getArgument(0)->isNull(); } -std::string IfcDocumentElectronicFormat::FileExtension() const { return *entity->getArgument(0); } -void IfcDocumentElectronicFormat::setFileExtension(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcDocumentElectronicFormat::hasMimeContentType() const { return !entity->getArgument(1)->isNull(); } -std::string IfcDocumentElectronicFormat::MimeContentType() const { return *entity->getArgument(1); } -void IfcDocumentElectronicFormat::setMimeContentType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcDocumentElectronicFormat::hasMimeSubtype() const { return !entity->getArgument(2)->isNull(); } -std::string IfcDocumentElectronicFormat::MimeSubtype() const { return *entity->getArgument(2); } -void IfcDocumentElectronicFormat::setMimeSubtype(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcDocumentElectronicFormat::is(Type::Enum v) const { return v == Type::IfcDocumentElectronicFormat; } -Type::Enum IfcDocumentElectronicFormat::type() const { return Type::IfcDocumentElectronicFormat; } +bool IfcDocumentElectronicFormat::hasFileExtension() const { return !data_->getArgument(0)->isNull(); } +std::string IfcDocumentElectronicFormat::FileExtension() const { return *data_->getArgument(0); } +void IfcDocumentElectronicFormat::setFileExtension(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcDocumentElectronicFormat::hasMimeContentType() const { return !data_->getArgument(1)->isNull(); } +std::string IfcDocumentElectronicFormat::MimeContentType() const { return *data_->getArgument(1); } +void IfcDocumentElectronicFormat::setMimeContentType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcDocumentElectronicFormat::hasMimeSubtype() const { return !data_->getArgument(2)->isNull(); } +std::string IfcDocumentElectronicFormat::MimeSubtype() const { return *data_->getArgument(2); } +void IfcDocumentElectronicFormat::setMimeSubtype(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcDocumentElectronicFormat::declaration() const { return *IfcDocumentElectronicFormat_type; } Type::Enum IfcDocumentElectronicFormat::Class() { return Type::IfcDocumentElectronicFormat; } -IfcDocumentElectronicFormat::IfcDocumentElectronicFormat(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDocumentElectronicFormat)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDocumentElectronicFormat::IfcDocumentElectronicFormat(boost::optional< std::string > v1_FileExtension, boost::optional< std::string > v2_MimeContentType, boost::optional< std::string > v3_MimeSubtype) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_FileExtension) { e->setArgument(0,(*v1_FileExtension)); } else { e->setArgument(0); } if (v2_MimeContentType) { e->setArgument(1,(*v2_MimeContentType)); } else { e->setArgument(1); } if (v3_MimeSubtype) { e->setArgument(2,(*v3_MimeSubtype)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcDocumentElectronicFormat::IfcDocumentElectronicFormat(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDocumentElectronicFormat)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDocumentElectronicFormat::IfcDocumentElectronicFormat(boost::optional< std::string > v1_FileExtension, boost::optional< std::string > v2_MimeContentType, boost::optional< std::string > v3_MimeSubtype) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_FileExtension) { e->setArgument(0,(*v1_FileExtension)); } else { e->setArgument(0); } if (v2_MimeContentType) { e->setArgument(1,(*v2_MimeContentType)); } else { e->setArgument(1); } if (v3_MimeSubtype) { e->setArgument(2,(*v3_MimeSubtype)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDocumentInformation -std::string IfcDocumentInformation::DocumentId() const { return *entity->getArgument(0); } -void IfcDocumentInformation::setDocumentId(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -std::string IfcDocumentInformation::Name() const { return *entity->getArgument(1); } -void IfcDocumentInformation::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcDocumentInformation::hasDescription() const { return !entity->getArgument(2)->isNull(); } -std::string IfcDocumentInformation::Description() const { return *entity->getArgument(2); } -void IfcDocumentInformation::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcDocumentInformation::hasDocumentReferences() const { return !entity->getArgument(3)->isNull(); } -IfcTemplatedEntityList< IfcDocumentReference >::ptr IfcDocumentInformation::DocumentReferences() const { IfcEntityList::ptr es = *entity->getArgument(3); return es->as(); } -void IfcDocumentInformation::setDocumentReferences(IfcTemplatedEntityList< IfcDocumentReference >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v->generalize()); } -bool IfcDocumentInformation::hasPurpose() const { return !entity->getArgument(4)->isNull(); } -std::string IfcDocumentInformation::Purpose() const { return *entity->getArgument(4); } -void IfcDocumentInformation::setPurpose(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcDocumentInformation::hasIntendedUse() const { return !entity->getArgument(5)->isNull(); } -std::string IfcDocumentInformation::IntendedUse() const { return *entity->getArgument(5); } -void IfcDocumentInformation::setIntendedUse(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcDocumentInformation::hasScope() const { return !entity->getArgument(6)->isNull(); } -std::string IfcDocumentInformation::Scope() const { return *entity->getArgument(6); } -void IfcDocumentInformation::setScope(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcDocumentInformation::hasRevision() const { return !entity->getArgument(7)->isNull(); } -std::string IfcDocumentInformation::Revision() const { return *entity->getArgument(7); } -void IfcDocumentInformation::setRevision(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcDocumentInformation::hasDocumentOwner() const { return !entity->getArgument(8)->isNull(); } -IfcActorSelect* IfcDocumentInformation::DocumentOwner() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcDocumentInformation::setDocumentOwner(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcDocumentInformation::hasEditors() const { return !entity->getArgument(9)->isNull(); } -IfcEntityList::ptr IfcDocumentInformation::Editors() const { return *entity->getArgument(9); } -void IfcDocumentInformation::setEditors(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcDocumentInformation::hasCreationTime() const { return !entity->getArgument(10)->isNull(); } -IfcDateAndTime* IfcDocumentInformation::CreationTime() const { return (IfcDateAndTime*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcDocumentInformation::setCreationTime(IfcDateAndTime* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcDocumentInformation::hasLastRevisionTime() const { return !entity->getArgument(11)->isNull(); } -IfcDateAndTime* IfcDocumentInformation::LastRevisionTime() const { return (IfcDateAndTime*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(11))); } -void IfcDocumentInformation::setLastRevisionTime(IfcDateAndTime* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcDocumentInformation::hasElectronicFormat() const { return !entity->getArgument(12)->isNull(); } -IfcDocumentElectronicFormat* IfcDocumentInformation::ElectronicFormat() const { return (IfcDocumentElectronicFormat*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(12))); } -void IfcDocumentInformation::setElectronicFormat(IfcDocumentElectronicFormat* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcDocumentInformation::hasValidFrom() const { return !entity->getArgument(13)->isNull(); } -IfcCalendarDate* IfcDocumentInformation::ValidFrom() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(13))); } -void IfcDocumentInformation::setValidFrom(IfcCalendarDate* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcDocumentInformation::hasValidUntil() const { return !entity->getArgument(14)->isNull(); } -IfcCalendarDate* IfcDocumentInformation::ValidUntil() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(14))); } -void IfcDocumentInformation::setValidUntil(IfcCalendarDate* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcDocumentInformation::hasConfidentiality() const { return !entity->getArgument(15)->isNull(); } -IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum IfcDocumentInformation::Confidentiality() const { return IfcDocumentConfidentialityEnum::FromString(*entity->getArgument(15)); } -void IfcDocumentInformation::setConfidentiality(IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v,IfcDocumentConfidentialityEnum::ToString(v)); } -bool IfcDocumentInformation::hasStatus() const { return !entity->getArgument(16)->isNull(); } -IfcDocumentStatusEnum::IfcDocumentStatusEnum IfcDocumentInformation::Status() const { return IfcDocumentStatusEnum::FromString(*entity->getArgument(16)); } -void IfcDocumentInformation::setStatus(IfcDocumentStatusEnum::IfcDocumentStatusEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(16,v,IfcDocumentStatusEnum::ToString(v)); } -IfcDocumentInformationRelationship::list::ptr IfcDocumentInformation::IsPointedTo() const { return entity->getInverse(Type::IfcDocumentInformationRelationship, 1)->as(); } -IfcDocumentInformationRelationship::list::ptr IfcDocumentInformation::IsPointer() const { return entity->getInverse(Type::IfcDocumentInformationRelationship, 0)->as(); } -bool IfcDocumentInformation::is(Type::Enum v) const { return v == Type::IfcDocumentInformation; } -Type::Enum IfcDocumentInformation::type() const { return Type::IfcDocumentInformation; } +std::string IfcDocumentInformation::DocumentId() const { return *data_->getArgument(0); } +void IfcDocumentInformation::setDocumentId(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +std::string IfcDocumentInformation::Name() const { return *data_->getArgument(1); } +void IfcDocumentInformation::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcDocumentInformation::hasDescription() const { return !data_->getArgument(2)->isNull(); } +std::string IfcDocumentInformation::Description() const { return *data_->getArgument(2); } +void IfcDocumentInformation::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcDocumentInformation::hasDocumentReferences() const { return !data_->getArgument(3)->isNull(); } +IfcTemplatedEntityList< IfcDocumentReference >::ptr IfcDocumentInformation::DocumentReferences() const { IfcEntityList::ptr es = *data_->getArgument(3); return es->as(); } +void IfcDocumentInformation::setDocumentReferences(IfcTemplatedEntityList< IfcDocumentReference >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v->generalize()); } +bool IfcDocumentInformation::hasPurpose() const { return !data_->getArgument(4)->isNull(); } +std::string IfcDocumentInformation::Purpose() const { return *data_->getArgument(4); } +void IfcDocumentInformation::setPurpose(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcDocumentInformation::hasIntendedUse() const { return !data_->getArgument(5)->isNull(); } +std::string IfcDocumentInformation::IntendedUse() const { return *data_->getArgument(5); } +void IfcDocumentInformation::setIntendedUse(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcDocumentInformation::hasScope() const { return !data_->getArgument(6)->isNull(); } +std::string IfcDocumentInformation::Scope() const { return *data_->getArgument(6); } +void IfcDocumentInformation::setScope(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcDocumentInformation::hasRevision() const { return !data_->getArgument(7)->isNull(); } +std::string IfcDocumentInformation::Revision() const { return *data_->getArgument(7); } +void IfcDocumentInformation::setRevision(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcDocumentInformation::hasDocumentOwner() const { return !data_->getArgument(8)->isNull(); } +IfcActorSelect* IfcDocumentInformation::DocumentOwner() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcDocumentInformation::setDocumentOwner(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcDocumentInformation::hasEditors() const { return !data_->getArgument(9)->isNull(); } +IfcEntityList::ptr IfcDocumentInformation::Editors() const { return *data_->getArgument(9); } +void IfcDocumentInformation::setEditors(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcDocumentInformation::hasCreationTime() const { return !data_->getArgument(10)->isNull(); } +IfcDateAndTime* IfcDocumentInformation::CreationTime() const { return (IfcDateAndTime*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcDocumentInformation::setCreationTime(IfcDateAndTime* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcDocumentInformation::hasLastRevisionTime() const { return !data_->getArgument(11)->isNull(); } +IfcDateAndTime* IfcDocumentInformation::LastRevisionTime() const { return (IfcDateAndTime*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(11))); } +void IfcDocumentInformation::setLastRevisionTime(IfcDateAndTime* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcDocumentInformation::hasElectronicFormat() const { return !data_->getArgument(12)->isNull(); } +IfcDocumentElectronicFormat* IfcDocumentInformation::ElectronicFormat() const { return (IfcDocumentElectronicFormat*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(12))); } +void IfcDocumentInformation::setElectronicFormat(IfcDocumentElectronicFormat* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcDocumentInformation::hasValidFrom() const { return !data_->getArgument(13)->isNull(); } +IfcCalendarDate* IfcDocumentInformation::ValidFrom() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(13))); } +void IfcDocumentInformation::setValidFrom(IfcCalendarDate* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcDocumentInformation::hasValidUntil() const { return !data_->getArgument(14)->isNull(); } +IfcCalendarDate* IfcDocumentInformation::ValidUntil() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(14))); } +void IfcDocumentInformation::setValidUntil(IfcCalendarDate* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } +bool IfcDocumentInformation::hasConfidentiality() const { return !data_->getArgument(15)->isNull(); } +IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum IfcDocumentInformation::Confidentiality() const { return IfcDocumentConfidentialityEnum::FromString(*data_->getArgument(15)); } +void IfcDocumentInformation::setConfidentiality(IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v,IfcDocumentConfidentialityEnum::ToString(v)); } +bool IfcDocumentInformation::hasStatus() const { return !data_->getArgument(16)->isNull(); } +IfcDocumentStatusEnum::IfcDocumentStatusEnum IfcDocumentInformation::Status() const { return IfcDocumentStatusEnum::FromString(*data_->getArgument(16)); } +void IfcDocumentInformation::setStatus(IfcDocumentStatusEnum::IfcDocumentStatusEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(16,v,IfcDocumentStatusEnum::ToString(v)); } + +IfcDocumentInformationRelationship::list::ptr IfcDocumentInformation::IsPointedTo() const { return data_->getInverse(Type::IfcDocumentInformationRelationship, 1)->as(); } +IfcDocumentInformationRelationship::list::ptr IfcDocumentInformation::IsPointer() const { return data_->getInverse(Type::IfcDocumentInformationRelationship, 0)->as(); } + +const IfcParse::entity& IfcDocumentInformation::declaration() const { return *IfcDocumentInformation_type; } Type::Enum IfcDocumentInformation::Class() { return Type::IfcDocumentInformation; } -IfcDocumentInformation::IfcDocumentInformation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDocumentInformation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDocumentInformation::IfcDocumentInformation(std::string v1_DocumentId, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< IfcTemplatedEntityList< IfcDocumentReference >::ptr > v4_DocumentReferences, boost::optional< std::string > v5_Purpose, boost::optional< std::string > v6_IntendedUse, boost::optional< std::string > v7_Scope, boost::optional< std::string > v8_Revision, IfcActorSelect* v9_DocumentOwner, boost::optional< IfcEntityList::ptr > v10_Editors, IfcDateAndTime* v11_CreationTime, IfcDateAndTime* v12_LastRevisionTime, IfcDocumentElectronicFormat* v13_ElectronicFormat, IfcCalendarDate* v14_ValidFrom, IfcCalendarDate* v15_ValidUntil, boost::optional< IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum > v16_Confidentiality, boost::optional< IfcDocumentStatusEnum::IfcDocumentStatusEnum > v17_Status) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DocumentId)); e->setArgument(1,(v2_Name)); if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } if (v4_DocumentReferences) { e->setArgument(3,(*v4_DocumentReferences)->generalize()); } else { e->setArgument(3); } if (v5_Purpose) { e->setArgument(4,(*v5_Purpose)); } else { e->setArgument(4); } if (v6_IntendedUse) { e->setArgument(5,(*v6_IntendedUse)); } else { e->setArgument(5); } if (v7_Scope) { e->setArgument(6,(*v7_Scope)); } else { e->setArgument(6); } if (v8_Revision) { e->setArgument(7,(*v8_Revision)); } else { e->setArgument(7); } e->setArgument(8,(v9_DocumentOwner)); if (v10_Editors) { e->setArgument(9,(*v10_Editors)); } else { e->setArgument(9); } e->setArgument(10,(v11_CreationTime)); e->setArgument(11,(v12_LastRevisionTime)); e->setArgument(12,(v13_ElectronicFormat)); e->setArgument(13,(v14_ValidFrom)); e->setArgument(14,(v15_ValidUntil)); if (v16_Confidentiality) { e->setArgument(15,*v16_Confidentiality,IfcDocumentConfidentialityEnum::ToString(*v16_Confidentiality)); } else { e->setArgument(15); } if (v17_Status) { e->setArgument(16,*v17_Status,IfcDocumentStatusEnum::ToString(*v17_Status)); } else { e->setArgument(16); } entity = e; EntityBuffer::Add(this); } +IfcDocumentInformation::IfcDocumentInformation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDocumentInformation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDocumentInformation::IfcDocumentInformation(std::string v1_DocumentId, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< IfcTemplatedEntityList< IfcDocumentReference >::ptr > v4_DocumentReferences, boost::optional< std::string > v5_Purpose, boost::optional< std::string > v6_IntendedUse, boost::optional< std::string > v7_Scope, boost::optional< std::string > v8_Revision, IfcActorSelect* v9_DocumentOwner, boost::optional< IfcEntityList::ptr > v10_Editors, IfcDateAndTime* v11_CreationTime, IfcDateAndTime* v12_LastRevisionTime, IfcDocumentElectronicFormat* v13_ElectronicFormat, IfcCalendarDate* v14_ValidFrom, IfcCalendarDate* v15_ValidUntil, boost::optional< IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum > v16_Confidentiality, boost::optional< IfcDocumentStatusEnum::IfcDocumentStatusEnum > v17_Status) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DocumentId)); e->setArgument(1,(v2_Name)); if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } if (v4_DocumentReferences) { e->setArgument(3,(*v4_DocumentReferences)->generalize()); } else { e->setArgument(3); } if (v5_Purpose) { e->setArgument(4,(*v5_Purpose)); } else { e->setArgument(4); } if (v6_IntendedUse) { e->setArgument(5,(*v6_IntendedUse)); } else { e->setArgument(5); } if (v7_Scope) { e->setArgument(6,(*v7_Scope)); } else { e->setArgument(6); } if (v8_Revision) { e->setArgument(7,(*v8_Revision)); } else { e->setArgument(7); } e->setArgument(8,(v9_DocumentOwner)); if (v10_Editors) { e->setArgument(9,(*v10_Editors)); } else { e->setArgument(9); } e->setArgument(10,(v11_CreationTime)); e->setArgument(11,(v12_LastRevisionTime)); e->setArgument(12,(v13_ElectronicFormat)); e->setArgument(13,(v14_ValidFrom)); e->setArgument(14,(v15_ValidUntil)); if (v16_Confidentiality) { e->setArgument(15,*v16_Confidentiality,IfcDocumentConfidentialityEnum::ToString(*v16_Confidentiality)); } else { e->setArgument(15); } if (v17_Status) { e->setArgument(16,*v17_Status,IfcDocumentStatusEnum::ToString(*v17_Status)); } else { e->setArgument(16); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDocumentInformationRelationship -IfcDocumentInformation* IfcDocumentInformationRelationship::RelatingDocument() const { return (IfcDocumentInformation*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcDocumentInformationRelationship::setRelatingDocument(IfcDocumentInformation* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcTemplatedEntityList< IfcDocumentInformation >::ptr IfcDocumentInformationRelationship::RelatedDocuments() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcDocumentInformationRelationship::setRelatedDocuments(IfcTemplatedEntityList< IfcDocumentInformation >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcDocumentInformationRelationship::hasRelationshipType() const { return !entity->getArgument(2)->isNull(); } -std::string IfcDocumentInformationRelationship::RelationshipType() const { return *entity->getArgument(2); } -void IfcDocumentInformationRelationship::setRelationshipType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcDocumentInformationRelationship::is(Type::Enum v) const { return v == Type::IfcDocumentInformationRelationship; } -Type::Enum IfcDocumentInformationRelationship::type() const { return Type::IfcDocumentInformationRelationship; } +IfcDocumentInformation* IfcDocumentInformationRelationship::RelatingDocument() const { return (IfcDocumentInformation*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcDocumentInformationRelationship::setRelatingDocument(IfcDocumentInformation* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcTemplatedEntityList< IfcDocumentInformation >::ptr IfcDocumentInformationRelationship::RelatedDocuments() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcDocumentInformationRelationship::setRelatedDocuments(IfcTemplatedEntityList< IfcDocumentInformation >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +bool IfcDocumentInformationRelationship::hasRelationshipType() const { return !data_->getArgument(2)->isNull(); } +std::string IfcDocumentInformationRelationship::RelationshipType() const { return *data_->getArgument(2); } +void IfcDocumentInformationRelationship::setRelationshipType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcDocumentInformationRelationship::declaration() const { return *IfcDocumentInformationRelationship_type; } Type::Enum IfcDocumentInformationRelationship::Class() { return Type::IfcDocumentInformationRelationship; } -IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDocumentInformationRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(IfcDocumentInformation* v1_RelatingDocument, IfcTemplatedEntityList< IfcDocumentInformation >::ptr v2_RelatedDocuments, boost::optional< std::string > v3_RelationshipType) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelatingDocument)); e->setArgument(1,(v2_RelatedDocuments)->generalize()); if (v3_RelationshipType) { e->setArgument(2,(*v3_RelationshipType)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDocumentInformationRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(IfcDocumentInformation* v1_RelatingDocument, IfcTemplatedEntityList< IfcDocumentInformation >::ptr v2_RelatedDocuments, boost::optional< std::string > v3_RelationshipType) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelatingDocument)); e->setArgument(1,(v2_RelatedDocuments)->generalize()); if (v3_RelationshipType) { e->setArgument(2,(*v3_RelationshipType)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDocumentReference -IfcDocumentInformation::list::ptr IfcDocumentReference::ReferenceToDocument() const { return entity->getInverse(Type::IfcDocumentInformation, 3)->as(); } -bool IfcDocumentReference::is(Type::Enum v) const { return v == Type::IfcDocumentReference || IfcExternalReference::is(v); } -Type::Enum IfcDocumentReference::type() const { return Type::IfcDocumentReference; } + +IfcDocumentInformation::list::ptr IfcDocumentReference::ReferenceToDocument() const { return data_->getInverse(Type::IfcDocumentInformation, 3)->as(); } + +const IfcParse::entity& IfcDocumentReference::declaration() const { return *IfcDocumentReference_type; } Type::Enum IfcDocumentReference::Class() { return Type::IfcDocumentReference; } -IfcDocumentReference::IfcDocumentReference(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDocumentReference)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDocumentReference::IfcDocumentReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcDocumentReference::IfcDocumentReference(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDocumentReference)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDocumentReference::IfcDocumentReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDoor -bool IfcDoor::hasOverallHeight() const { return !entity->getArgument(8)->isNull(); } -double IfcDoor::OverallHeight() const { return *entity->getArgument(8); } -void IfcDoor::setOverallHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcDoor::hasOverallWidth() const { return !entity->getArgument(9)->isNull(); } -double IfcDoor::OverallWidth() const { return *entity->getArgument(9); } -void IfcDoor::setOverallWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcDoor::is(Type::Enum v) const { return v == Type::IfcDoor || IfcBuildingElement::is(v); } -Type::Enum IfcDoor::type() const { return Type::IfcDoor; } +bool IfcDoor::hasOverallHeight() const { return !data_->getArgument(8)->isNull(); } +double IfcDoor::OverallHeight() const { return *data_->getArgument(8); } +void IfcDoor::setOverallHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcDoor::hasOverallWidth() const { return !data_->getArgument(9)->isNull(); } +double IfcDoor::OverallWidth() const { return *data_->getArgument(9); } +void IfcDoor::setOverallWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcDoor::declaration() const { return *IfcDoor_type; } Type::Enum IfcDoor::Class() { return Type::IfcDoor; } -IfcDoor::IfcDoor(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDoor::IfcDoor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_OverallHeight, boost::optional< double > v10_OverallWidth) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_OverallHeight) { e->setArgument(8,(*v9_OverallHeight)); } else { e->setArgument(8); } if (v10_OverallWidth) { e->setArgument(9,(*v10_OverallWidth)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcDoor::IfcDoor(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDoor::IfcDoor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_OverallHeight, boost::optional< double > v10_OverallWidth) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_OverallHeight) { e->setArgument(8,(*v9_OverallHeight)); } else { e->setArgument(8); } if (v10_OverallWidth) { e->setArgument(9,(*v10_OverallWidth)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDoorLiningProperties -bool IfcDoorLiningProperties::hasLiningDepth() const { return !entity->getArgument(4)->isNull(); } -double IfcDoorLiningProperties::LiningDepth() const { return *entity->getArgument(4); } -void IfcDoorLiningProperties::setLiningDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcDoorLiningProperties::hasLiningThickness() const { return !entity->getArgument(5)->isNull(); } -double IfcDoorLiningProperties::LiningThickness() const { return *entity->getArgument(5); } -void IfcDoorLiningProperties::setLiningThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcDoorLiningProperties::hasThresholdDepth() const { return !entity->getArgument(6)->isNull(); } -double IfcDoorLiningProperties::ThresholdDepth() const { return *entity->getArgument(6); } -void IfcDoorLiningProperties::setThresholdDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcDoorLiningProperties::hasThresholdThickness() const { return !entity->getArgument(7)->isNull(); } -double IfcDoorLiningProperties::ThresholdThickness() const { return *entity->getArgument(7); } -void IfcDoorLiningProperties::setThresholdThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcDoorLiningProperties::hasTransomThickness() const { return !entity->getArgument(8)->isNull(); } -double IfcDoorLiningProperties::TransomThickness() const { return *entity->getArgument(8); } -void IfcDoorLiningProperties::setTransomThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcDoorLiningProperties::hasTransomOffset() const { return !entity->getArgument(9)->isNull(); } -double IfcDoorLiningProperties::TransomOffset() const { return *entity->getArgument(9); } -void IfcDoorLiningProperties::setTransomOffset(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcDoorLiningProperties::hasLiningOffset() const { return !entity->getArgument(10)->isNull(); } -double IfcDoorLiningProperties::LiningOffset() const { return *entity->getArgument(10); } -void IfcDoorLiningProperties::setLiningOffset(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcDoorLiningProperties::hasThresholdOffset() const { return !entity->getArgument(11)->isNull(); } -double IfcDoorLiningProperties::ThresholdOffset() const { return *entity->getArgument(11); } -void IfcDoorLiningProperties::setThresholdOffset(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcDoorLiningProperties::hasCasingThickness() const { return !entity->getArgument(12)->isNull(); } -double IfcDoorLiningProperties::CasingThickness() const { return *entity->getArgument(12); } -void IfcDoorLiningProperties::setCasingThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcDoorLiningProperties::hasCasingDepth() const { return !entity->getArgument(13)->isNull(); } -double IfcDoorLiningProperties::CasingDepth() const { return *entity->getArgument(13); } -void IfcDoorLiningProperties::setCasingDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcDoorLiningProperties::hasShapeAspectStyle() const { return !entity->getArgument(14)->isNull(); } -IfcShapeAspect* IfcDoorLiningProperties::ShapeAspectStyle() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(14))); } -void IfcDoorLiningProperties::setShapeAspectStyle(IfcShapeAspect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcDoorLiningProperties::is(Type::Enum v) const { return v == Type::IfcDoorLiningProperties || IfcPropertySetDefinition::is(v); } -Type::Enum IfcDoorLiningProperties::type() const { return Type::IfcDoorLiningProperties; } +bool IfcDoorLiningProperties::hasLiningDepth() const { return !data_->getArgument(4)->isNull(); } +double IfcDoorLiningProperties::LiningDepth() const { return *data_->getArgument(4); } +void IfcDoorLiningProperties::setLiningDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcDoorLiningProperties::hasLiningThickness() const { return !data_->getArgument(5)->isNull(); } +double IfcDoorLiningProperties::LiningThickness() const { return *data_->getArgument(5); } +void IfcDoorLiningProperties::setLiningThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcDoorLiningProperties::hasThresholdDepth() const { return !data_->getArgument(6)->isNull(); } +double IfcDoorLiningProperties::ThresholdDepth() const { return *data_->getArgument(6); } +void IfcDoorLiningProperties::setThresholdDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcDoorLiningProperties::hasThresholdThickness() const { return !data_->getArgument(7)->isNull(); } +double IfcDoorLiningProperties::ThresholdThickness() const { return *data_->getArgument(7); } +void IfcDoorLiningProperties::setThresholdThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcDoorLiningProperties::hasTransomThickness() const { return !data_->getArgument(8)->isNull(); } +double IfcDoorLiningProperties::TransomThickness() const { return *data_->getArgument(8); } +void IfcDoorLiningProperties::setTransomThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcDoorLiningProperties::hasTransomOffset() const { return !data_->getArgument(9)->isNull(); } +double IfcDoorLiningProperties::TransomOffset() const { return *data_->getArgument(9); } +void IfcDoorLiningProperties::setTransomOffset(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcDoorLiningProperties::hasLiningOffset() const { return !data_->getArgument(10)->isNull(); } +double IfcDoorLiningProperties::LiningOffset() const { return *data_->getArgument(10); } +void IfcDoorLiningProperties::setLiningOffset(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcDoorLiningProperties::hasThresholdOffset() const { return !data_->getArgument(11)->isNull(); } +double IfcDoorLiningProperties::ThresholdOffset() const { return *data_->getArgument(11); } +void IfcDoorLiningProperties::setThresholdOffset(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcDoorLiningProperties::hasCasingThickness() const { return !data_->getArgument(12)->isNull(); } +double IfcDoorLiningProperties::CasingThickness() const { return *data_->getArgument(12); } +void IfcDoorLiningProperties::setCasingThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcDoorLiningProperties::hasCasingDepth() const { return !data_->getArgument(13)->isNull(); } +double IfcDoorLiningProperties::CasingDepth() const { return *data_->getArgument(13); } +void IfcDoorLiningProperties::setCasingDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcDoorLiningProperties::hasShapeAspectStyle() const { return !data_->getArgument(14)->isNull(); } +IfcShapeAspect* IfcDoorLiningProperties::ShapeAspectStyle() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(14))); } +void IfcDoorLiningProperties::setShapeAspectStyle(IfcShapeAspect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } + + +const IfcParse::entity& IfcDoorLiningProperties::declaration() const { return *IfcDoorLiningProperties_type; } Type::Enum IfcDoorLiningProperties::Class() { return Type::IfcDoorLiningProperties; } -IfcDoorLiningProperties::IfcDoorLiningProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoorLiningProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDoorLiningProperties::IfcDoorLiningProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_LiningDepth, boost::optional< double > v6_LiningThickness, boost::optional< double > v7_ThresholdDepth, boost::optional< double > v8_ThresholdThickness, boost::optional< double > v9_TransomThickness, boost::optional< double > v10_TransomOffset, boost::optional< double > v11_LiningOffset, boost::optional< double > v12_ThresholdOffset, boost::optional< double > v13_CasingThickness, boost::optional< double > v14_CasingDepth, IfcShapeAspect* v15_ShapeAspectStyle) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_LiningDepth) { e->setArgument(4,(*v5_LiningDepth)); } else { e->setArgument(4); } if (v6_LiningThickness) { e->setArgument(5,(*v6_LiningThickness)); } else { e->setArgument(5); } if (v7_ThresholdDepth) { e->setArgument(6,(*v7_ThresholdDepth)); } else { e->setArgument(6); } if (v8_ThresholdThickness) { e->setArgument(7,(*v8_ThresholdThickness)); } else { e->setArgument(7); } if (v9_TransomThickness) { e->setArgument(8,(*v9_TransomThickness)); } else { e->setArgument(8); } if (v10_TransomOffset) { e->setArgument(9,(*v10_TransomOffset)); } else { e->setArgument(9); } if (v11_LiningOffset) { e->setArgument(10,(*v11_LiningOffset)); } else { e->setArgument(10); } if (v12_ThresholdOffset) { e->setArgument(11,(*v12_ThresholdOffset)); } else { e->setArgument(11); } if (v13_CasingThickness) { e->setArgument(12,(*v13_CasingThickness)); } else { e->setArgument(12); } if (v14_CasingDepth) { e->setArgument(13,(*v14_CasingDepth)); } else { e->setArgument(13); } e->setArgument(14,(v15_ShapeAspectStyle)); entity = e; EntityBuffer::Add(this); } +IfcDoorLiningProperties::IfcDoorLiningProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoorLiningProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDoorLiningProperties::IfcDoorLiningProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_LiningDepth, boost::optional< double > v6_LiningThickness, boost::optional< double > v7_ThresholdDepth, boost::optional< double > v8_ThresholdThickness, boost::optional< double > v9_TransomThickness, boost::optional< double > v10_TransomOffset, boost::optional< double > v11_LiningOffset, boost::optional< double > v12_ThresholdOffset, boost::optional< double > v13_CasingThickness, boost::optional< double > v14_CasingDepth, IfcShapeAspect* v15_ShapeAspectStyle) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_LiningDepth) { e->setArgument(4,(*v5_LiningDepth)); } else { e->setArgument(4); } if (v6_LiningThickness) { e->setArgument(5,(*v6_LiningThickness)); } else { e->setArgument(5); } if (v7_ThresholdDepth) { e->setArgument(6,(*v7_ThresholdDepth)); } else { e->setArgument(6); } if (v8_ThresholdThickness) { e->setArgument(7,(*v8_ThresholdThickness)); } else { e->setArgument(7); } if (v9_TransomThickness) { e->setArgument(8,(*v9_TransomThickness)); } else { e->setArgument(8); } if (v10_TransomOffset) { e->setArgument(9,(*v10_TransomOffset)); } else { e->setArgument(9); } if (v11_LiningOffset) { e->setArgument(10,(*v11_LiningOffset)); } else { e->setArgument(10); } if (v12_ThresholdOffset) { e->setArgument(11,(*v12_ThresholdOffset)); } else { e->setArgument(11); } if (v13_CasingThickness) { e->setArgument(12,(*v13_CasingThickness)); } else { e->setArgument(12); } if (v14_CasingDepth) { e->setArgument(13,(*v14_CasingDepth)); } else { e->setArgument(13); } e->setArgument(14,(v15_ShapeAspectStyle)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDoorPanelProperties -bool IfcDoorPanelProperties::hasPanelDepth() const { return !entity->getArgument(4)->isNull(); } -double IfcDoorPanelProperties::PanelDepth() const { return *entity->getArgument(4); } -void IfcDoorPanelProperties::setPanelDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum IfcDoorPanelProperties::PanelOperation() const { return IfcDoorPanelOperationEnum::FromString(*entity->getArgument(5)); } -void IfcDoorPanelProperties::setPanelOperation(IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcDoorPanelOperationEnum::ToString(v)); } -bool IfcDoorPanelProperties::hasPanelWidth() const { return !entity->getArgument(6)->isNull(); } -double IfcDoorPanelProperties::PanelWidth() const { return *entity->getArgument(6); } -void IfcDoorPanelProperties::setPanelWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum IfcDoorPanelProperties::PanelPosition() const { return IfcDoorPanelPositionEnum::FromString(*entity->getArgument(7)); } -void IfcDoorPanelProperties::setPanelPosition(IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcDoorPanelPositionEnum::ToString(v)); } -bool IfcDoorPanelProperties::hasShapeAspectStyle() const { return !entity->getArgument(8)->isNull(); } -IfcShapeAspect* IfcDoorPanelProperties::ShapeAspectStyle() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcDoorPanelProperties::setShapeAspectStyle(IfcShapeAspect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcDoorPanelProperties::is(Type::Enum v) const { return v == Type::IfcDoorPanelProperties || IfcPropertySetDefinition::is(v); } -Type::Enum IfcDoorPanelProperties::type() const { return Type::IfcDoorPanelProperties; } +bool IfcDoorPanelProperties::hasPanelDepth() const { return !data_->getArgument(4)->isNull(); } +double IfcDoorPanelProperties::PanelDepth() const { return *data_->getArgument(4); } +void IfcDoorPanelProperties::setPanelDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum IfcDoorPanelProperties::PanelOperation() const { return IfcDoorPanelOperationEnum::FromString(*data_->getArgument(5)); } +void IfcDoorPanelProperties::setPanelOperation(IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcDoorPanelOperationEnum::ToString(v)); } +bool IfcDoorPanelProperties::hasPanelWidth() const { return !data_->getArgument(6)->isNull(); } +double IfcDoorPanelProperties::PanelWidth() const { return *data_->getArgument(6); } +void IfcDoorPanelProperties::setPanelWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum IfcDoorPanelProperties::PanelPosition() const { return IfcDoorPanelPositionEnum::FromString(*data_->getArgument(7)); } +void IfcDoorPanelProperties::setPanelPosition(IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcDoorPanelPositionEnum::ToString(v)); } +bool IfcDoorPanelProperties::hasShapeAspectStyle() const { return !data_->getArgument(8)->isNull(); } +IfcShapeAspect* IfcDoorPanelProperties::ShapeAspectStyle() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcDoorPanelProperties::setShapeAspectStyle(IfcShapeAspect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcDoorPanelProperties::declaration() const { return *IfcDoorPanelProperties_type; } Type::Enum IfcDoorPanelProperties::Class() { return Type::IfcDoorPanelProperties; } -IfcDoorPanelProperties::IfcDoorPanelProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoorPanelProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDoorPanelProperties::IfcDoorPanelProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_PanelDepth, IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum v6_PanelOperation, boost::optional< double > v7_PanelWidth, IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum v8_PanelPosition, IfcShapeAspect* v9_ShapeAspectStyle) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_PanelDepth) { e->setArgument(4,(*v5_PanelDepth)); } else { e->setArgument(4); } e->setArgument(5,v6_PanelOperation,IfcDoorPanelOperationEnum::ToString(v6_PanelOperation)); if (v7_PanelWidth) { e->setArgument(6,(*v7_PanelWidth)); } else { e->setArgument(6); } e->setArgument(7,v8_PanelPosition,IfcDoorPanelPositionEnum::ToString(v8_PanelPosition)); e->setArgument(8,(v9_ShapeAspectStyle)); entity = e; EntityBuffer::Add(this); } +IfcDoorPanelProperties::IfcDoorPanelProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoorPanelProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDoorPanelProperties::IfcDoorPanelProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_PanelDepth, IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum v6_PanelOperation, boost::optional< double > v7_PanelWidth, IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum v8_PanelPosition, IfcShapeAspect* v9_ShapeAspectStyle) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_PanelDepth) { e->setArgument(4,(*v5_PanelDepth)); } else { e->setArgument(4); } e->setArgument(5,v6_PanelOperation,IfcDoorPanelOperationEnum::ToString(v6_PanelOperation)); if (v7_PanelWidth) { e->setArgument(6,(*v7_PanelWidth)); } else { e->setArgument(6); } e->setArgument(7,v8_PanelPosition,IfcDoorPanelPositionEnum::ToString(v8_PanelPosition)); e->setArgument(8,(v9_ShapeAspectStyle)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDoorStyle -IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum IfcDoorStyle::OperationType() const { return IfcDoorStyleOperationEnum::FromString(*entity->getArgument(8)); } -void IfcDoorStyle::setOperationType(IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcDoorStyleOperationEnum::ToString(v)); } -IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum IfcDoorStyle::ConstructionType() const { return IfcDoorStyleConstructionEnum::FromString(*entity->getArgument(9)); } -void IfcDoorStyle::setConstructionType(IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcDoorStyleConstructionEnum::ToString(v)); } -bool IfcDoorStyle::ParameterTakesPrecedence() const { return *entity->getArgument(10); } -void IfcDoorStyle::setParameterTakesPrecedence(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcDoorStyle::Sizeable() const { return *entity->getArgument(11); } -void IfcDoorStyle::setSizeable(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcDoorStyle::is(Type::Enum v) const { return v == Type::IfcDoorStyle || IfcTypeProduct::is(v); } -Type::Enum IfcDoorStyle::type() const { return Type::IfcDoorStyle; } +IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum IfcDoorStyle::OperationType() const { return IfcDoorStyleOperationEnum::FromString(*data_->getArgument(8)); } +void IfcDoorStyle::setOperationType(IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcDoorStyleOperationEnum::ToString(v)); } +IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum IfcDoorStyle::ConstructionType() const { return IfcDoorStyleConstructionEnum::FromString(*data_->getArgument(9)); } +void IfcDoorStyle::setConstructionType(IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcDoorStyleConstructionEnum::ToString(v)); } +bool IfcDoorStyle::ParameterTakesPrecedence() const { return *data_->getArgument(10); } +void IfcDoorStyle::setParameterTakesPrecedence(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcDoorStyle::Sizeable() const { return *data_->getArgument(11); } +void IfcDoorStyle::setSizeable(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } + + +const IfcParse::entity& IfcDoorStyle::declaration() const { return *IfcDoorStyle_type; } Type::Enum IfcDoorStyle::Class() { return Type::IfcDoorStyle; } -IfcDoorStyle::IfcDoorStyle(IfcAbstractEntity* e) : IfcTypeProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoorStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDoorStyle::IfcDoorStyle(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum v9_OperationType, IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum v10_ConstructionType, bool v11_ParameterTakesPrecedence, bool v12_Sizeable) : IfcTypeProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_OperationType,IfcDoorStyleOperationEnum::ToString(v9_OperationType)); e->setArgument(9,v10_ConstructionType,IfcDoorStyleConstructionEnum::ToString(v10_ConstructionType)); e->setArgument(10,(v11_ParameterTakesPrecedence)); e->setArgument(11,(v12_Sizeable)); entity = e; EntityBuffer::Add(this); } +IfcDoorStyle::IfcDoorStyle(IfcAbstractEntity* e) : IfcTypeProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoorStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDoorStyle::IfcDoorStyle(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum v9_OperationType, IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum v10_ConstructionType, bool v11_ParameterTakesPrecedence, bool v12_Sizeable) : IfcTypeProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_OperationType,IfcDoorStyleOperationEnum::ToString(v9_OperationType)); e->setArgument(9,v10_ConstructionType,IfcDoorStyleConstructionEnum::ToString(v10_ConstructionType)); e->setArgument(10,(v11_ParameterTakesPrecedence)); e->setArgument(11,(v12_Sizeable)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDraughtingCallout -IfcEntityList::ptr IfcDraughtingCallout::Contents() const { return *entity->getArgument(0); } -void IfcDraughtingCallout::setContents(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcDraughtingCalloutRelationship::list::ptr IfcDraughtingCallout::IsRelatedFromCallout() const { return entity->getInverse(Type::IfcDraughtingCalloutRelationship, 3)->as(); } -IfcDraughtingCalloutRelationship::list::ptr IfcDraughtingCallout::IsRelatedToCallout() const { return entity->getInverse(Type::IfcDraughtingCalloutRelationship, 2)->as(); } -bool IfcDraughtingCallout::is(Type::Enum v) const { return v == Type::IfcDraughtingCallout || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcDraughtingCallout::type() const { return Type::IfcDraughtingCallout; } +IfcEntityList::ptr IfcDraughtingCallout::Contents() const { return *data_->getArgument(0); } +void IfcDraughtingCallout::setContents(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + +IfcDraughtingCalloutRelationship::list::ptr IfcDraughtingCallout::IsRelatedFromCallout() const { return data_->getInverse(Type::IfcDraughtingCalloutRelationship, 3)->as(); } +IfcDraughtingCalloutRelationship::list::ptr IfcDraughtingCallout::IsRelatedToCallout() const { return data_->getInverse(Type::IfcDraughtingCalloutRelationship, 2)->as(); } + +const IfcParse::entity& IfcDraughtingCallout::declaration() const { return *IfcDraughtingCallout_type; } Type::Enum IfcDraughtingCallout::Class() { return Type::IfcDraughtingCallout; } -IfcDraughtingCallout::IfcDraughtingCallout(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDraughtingCallout)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDraughtingCallout::IfcDraughtingCallout(IfcEntityList::ptr v1_Contents) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); entity = e; EntityBuffer::Add(this); } +IfcDraughtingCallout::IfcDraughtingCallout(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDraughtingCallout)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDraughtingCallout::IfcDraughtingCallout(IfcEntityList::ptr v1_Contents) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDraughtingCalloutRelationship -bool IfcDraughtingCalloutRelationship::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcDraughtingCalloutRelationship::Name() const { return *entity->getArgument(0); } -void IfcDraughtingCalloutRelationship::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcDraughtingCalloutRelationship::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcDraughtingCalloutRelationship::Description() const { return *entity->getArgument(1); } -void IfcDraughtingCalloutRelationship::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcDraughtingCallout* IfcDraughtingCalloutRelationship::RelatingDraughtingCallout() const { return (IfcDraughtingCallout*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcDraughtingCalloutRelationship::setRelatingDraughtingCallout(IfcDraughtingCallout* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcDraughtingCallout* IfcDraughtingCalloutRelationship::RelatedDraughtingCallout() const { return (IfcDraughtingCallout*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcDraughtingCalloutRelationship::setRelatedDraughtingCallout(IfcDraughtingCallout* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcDraughtingCalloutRelationship::is(Type::Enum v) const { return v == Type::IfcDraughtingCalloutRelationship; } -Type::Enum IfcDraughtingCalloutRelationship::type() const { return Type::IfcDraughtingCalloutRelationship; } +bool IfcDraughtingCalloutRelationship::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcDraughtingCalloutRelationship::Name() const { return *data_->getArgument(0); } +void IfcDraughtingCalloutRelationship::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcDraughtingCalloutRelationship::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcDraughtingCalloutRelationship::Description() const { return *data_->getArgument(1); } +void IfcDraughtingCalloutRelationship::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcDraughtingCallout* IfcDraughtingCalloutRelationship::RelatingDraughtingCallout() const { return (IfcDraughtingCallout*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcDraughtingCalloutRelationship::setRelatingDraughtingCallout(IfcDraughtingCallout* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcDraughtingCallout* IfcDraughtingCalloutRelationship::RelatedDraughtingCallout() const { return (IfcDraughtingCallout*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcDraughtingCalloutRelationship::setRelatedDraughtingCallout(IfcDraughtingCallout* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcDraughtingCalloutRelationship::declaration() const { return *IfcDraughtingCalloutRelationship_type; } Type::Enum IfcDraughtingCalloutRelationship::Class() { return Type::IfcDraughtingCalloutRelationship; } -IfcDraughtingCalloutRelationship::IfcDraughtingCalloutRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDraughtingCalloutRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDraughtingCalloutRelationship::IfcDraughtingCalloutRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDraughtingCallout* v3_RelatingDraughtingCallout, IfcDraughtingCallout* v4_RelatedDraughtingCallout) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingDraughtingCallout)); e->setArgument(3,(v4_RelatedDraughtingCallout)); entity = e; EntityBuffer::Add(this); } +IfcDraughtingCalloutRelationship::IfcDraughtingCalloutRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcDraughtingCalloutRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDraughtingCalloutRelationship::IfcDraughtingCalloutRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDraughtingCallout* v3_RelatingDraughtingCallout, IfcDraughtingCallout* v4_RelatedDraughtingCallout) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingDraughtingCallout)); e->setArgument(3,(v4_RelatedDraughtingCallout)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDraughtingPreDefinedColour -bool IfcDraughtingPreDefinedColour::is(Type::Enum v) const { return v == Type::IfcDraughtingPreDefinedColour || IfcPreDefinedColour::is(v); } -Type::Enum IfcDraughtingPreDefinedColour::type() const { return Type::IfcDraughtingPreDefinedColour; } + + +const IfcParse::entity& IfcDraughtingPreDefinedColour::declaration() const { return *IfcDraughtingPreDefinedColour_type; } Type::Enum IfcDraughtingPreDefinedColour::Class() { return Type::IfcDraughtingPreDefinedColour; } -IfcDraughtingPreDefinedColour::IfcDraughtingPreDefinedColour(IfcAbstractEntity* e) : IfcPreDefinedColour((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDraughtingPreDefinedColour)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDraughtingPreDefinedColour::IfcDraughtingPreDefinedColour(std::string v1_Name) : IfcPreDefinedColour((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcDraughtingPreDefinedColour::IfcDraughtingPreDefinedColour(IfcAbstractEntity* e) : IfcPreDefinedColour((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDraughtingPreDefinedColour)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDraughtingPreDefinedColour::IfcDraughtingPreDefinedColour(std::string v1_Name) : IfcPreDefinedColour((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDraughtingPreDefinedCurveFont -bool IfcDraughtingPreDefinedCurveFont::is(Type::Enum v) const { return v == Type::IfcDraughtingPreDefinedCurveFont || IfcPreDefinedCurveFont::is(v); } -Type::Enum IfcDraughtingPreDefinedCurveFont::type() const { return Type::IfcDraughtingPreDefinedCurveFont; } + + +const IfcParse::entity& IfcDraughtingPreDefinedCurveFont::declaration() const { return *IfcDraughtingPreDefinedCurveFont_type; } Type::Enum IfcDraughtingPreDefinedCurveFont::Class() { return Type::IfcDraughtingPreDefinedCurveFont; } -IfcDraughtingPreDefinedCurveFont::IfcDraughtingPreDefinedCurveFont(IfcAbstractEntity* e) : IfcPreDefinedCurveFont((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDraughtingPreDefinedCurveFont)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDraughtingPreDefinedCurveFont::IfcDraughtingPreDefinedCurveFont(std::string v1_Name) : IfcPreDefinedCurveFont((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcDraughtingPreDefinedCurveFont::IfcDraughtingPreDefinedCurveFont(IfcAbstractEntity* e) : IfcPreDefinedCurveFont((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDraughtingPreDefinedCurveFont)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDraughtingPreDefinedCurveFont::IfcDraughtingPreDefinedCurveFont(std::string v1_Name) : IfcPreDefinedCurveFont((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDraughtingPreDefinedTextFont -bool IfcDraughtingPreDefinedTextFont::is(Type::Enum v) const { return v == Type::IfcDraughtingPreDefinedTextFont || IfcPreDefinedTextFont::is(v); } -Type::Enum IfcDraughtingPreDefinedTextFont::type() const { return Type::IfcDraughtingPreDefinedTextFont; } + + +const IfcParse::entity& IfcDraughtingPreDefinedTextFont::declaration() const { return *IfcDraughtingPreDefinedTextFont_type; } Type::Enum IfcDraughtingPreDefinedTextFont::Class() { return Type::IfcDraughtingPreDefinedTextFont; } -IfcDraughtingPreDefinedTextFont::IfcDraughtingPreDefinedTextFont(IfcAbstractEntity* e) : IfcPreDefinedTextFont((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDraughtingPreDefinedTextFont)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDraughtingPreDefinedTextFont::IfcDraughtingPreDefinedTextFont(std::string v1_Name) : IfcPreDefinedTextFont((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcDraughtingPreDefinedTextFont::IfcDraughtingPreDefinedTextFont(IfcAbstractEntity* e) : IfcPreDefinedTextFont((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDraughtingPreDefinedTextFont)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDraughtingPreDefinedTextFont::IfcDraughtingPreDefinedTextFont(std::string v1_Name) : IfcPreDefinedTextFont((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDuctFittingType -IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum IfcDuctFittingType::PredefinedType() const { return IfcDuctFittingTypeEnum::FromString(*entity->getArgument(9)); } -void IfcDuctFittingType::setPredefinedType(IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcDuctFittingTypeEnum::ToString(v)); } -bool IfcDuctFittingType::is(Type::Enum v) const { return v == Type::IfcDuctFittingType || IfcFlowFittingType::is(v); } -Type::Enum IfcDuctFittingType::type() const { return Type::IfcDuctFittingType; } +IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum IfcDuctFittingType::PredefinedType() const { return IfcDuctFittingTypeEnum::FromString(*data_->getArgument(9)); } +void IfcDuctFittingType::setPredefinedType(IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcDuctFittingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcDuctFittingType::declaration() const { return *IfcDuctFittingType_type; } Type::Enum IfcDuctFittingType::Class() { return Type::IfcDuctFittingType; } -IfcDuctFittingType::IfcDuctFittingType(IfcAbstractEntity* e) : IfcFlowFittingType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctFittingType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDuctFittingType::IfcDuctFittingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum v10_PredefinedType) : IfcFlowFittingType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcDuctFittingTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcDuctFittingType::IfcDuctFittingType(IfcAbstractEntity* e) : IfcFlowFittingType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctFittingType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDuctFittingType::IfcDuctFittingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum v10_PredefinedType) : IfcFlowFittingType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcDuctFittingTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDuctSegmentType -IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum IfcDuctSegmentType::PredefinedType() const { return IfcDuctSegmentTypeEnum::FromString(*entity->getArgument(9)); } -void IfcDuctSegmentType::setPredefinedType(IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcDuctSegmentTypeEnum::ToString(v)); } -bool IfcDuctSegmentType::is(Type::Enum v) const { return v == Type::IfcDuctSegmentType || IfcFlowSegmentType::is(v); } -Type::Enum IfcDuctSegmentType::type() const { return Type::IfcDuctSegmentType; } +IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum IfcDuctSegmentType::PredefinedType() const { return IfcDuctSegmentTypeEnum::FromString(*data_->getArgument(9)); } +void IfcDuctSegmentType::setPredefinedType(IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcDuctSegmentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcDuctSegmentType::declaration() const { return *IfcDuctSegmentType_type; } Type::Enum IfcDuctSegmentType::Class() { return Type::IfcDuctSegmentType; } -IfcDuctSegmentType::IfcDuctSegmentType(IfcAbstractEntity* e) : IfcFlowSegmentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctSegmentType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDuctSegmentType::IfcDuctSegmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum v10_PredefinedType) : IfcFlowSegmentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcDuctSegmentTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcDuctSegmentType::IfcDuctSegmentType(IfcAbstractEntity* e) : IfcFlowSegmentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctSegmentType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDuctSegmentType::IfcDuctSegmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum v10_PredefinedType) : IfcFlowSegmentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcDuctSegmentTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDuctSilencerType -IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum IfcDuctSilencerType::PredefinedType() const { return IfcDuctSilencerTypeEnum::FromString(*entity->getArgument(9)); } -void IfcDuctSilencerType::setPredefinedType(IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcDuctSilencerTypeEnum::ToString(v)); } -bool IfcDuctSilencerType::is(Type::Enum v) const { return v == Type::IfcDuctSilencerType || IfcFlowTreatmentDeviceType::is(v); } -Type::Enum IfcDuctSilencerType::type() const { return Type::IfcDuctSilencerType; } +IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum IfcDuctSilencerType::PredefinedType() const { return IfcDuctSilencerTypeEnum::FromString(*data_->getArgument(9)); } +void IfcDuctSilencerType::setPredefinedType(IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcDuctSilencerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcDuctSilencerType::declaration() const { return *IfcDuctSilencerType_type; } Type::Enum IfcDuctSilencerType::Class() { return Type::IfcDuctSilencerType; } -IfcDuctSilencerType::IfcDuctSilencerType(IfcAbstractEntity* e) : IfcFlowTreatmentDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctSilencerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDuctSilencerType::IfcDuctSilencerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum v10_PredefinedType) : IfcFlowTreatmentDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcDuctSilencerTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcDuctSilencerType::IfcDuctSilencerType(IfcAbstractEntity* e) : IfcFlowTreatmentDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctSilencerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDuctSilencerType::IfcDuctSilencerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum v10_PredefinedType) : IfcFlowTreatmentDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcDuctSilencerTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEdge -IfcVertex* IfcEdge::EdgeStart() const { return (IfcVertex*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcEdge::setEdgeStart(IfcVertex* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcVertex* IfcEdge::EdgeEnd() const { return (IfcVertex*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcEdge::setEdgeEnd(IfcVertex* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcEdge::is(Type::Enum v) const { return v == Type::IfcEdge || IfcTopologicalRepresentationItem::is(v); } -Type::Enum IfcEdge::type() const { return Type::IfcEdge; } +IfcVertex* IfcEdge::EdgeStart() const { return (IfcVertex*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcEdge::setEdgeStart(IfcVertex* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcVertex* IfcEdge::EdgeEnd() const { return (IfcVertex*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcEdge::setEdgeEnd(IfcVertex* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcEdge::declaration() const { return *IfcEdge_type; } Type::Enum IfcEdge::Class() { return Type::IfcEdge; } -IfcEdge::IfcEdge(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEdge)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEdge::IfcEdge(IfcVertex* v1_EdgeStart, IfcVertex* v2_EdgeEnd) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_EdgeStart)); e->setArgument(1,(v2_EdgeEnd)); entity = e; EntityBuffer::Add(this); } +IfcEdge::IfcEdge(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEdge)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEdge::IfcEdge(IfcVertex* v1_EdgeStart, IfcVertex* v2_EdgeEnd) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_EdgeStart)); e->setArgument(1,(v2_EdgeEnd)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEdgeCurve -IfcCurve* IfcEdgeCurve::EdgeGeometry() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcEdgeCurve::setEdgeGeometry(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcEdgeCurve::SameSense() const { return *entity->getArgument(3); } -void IfcEdgeCurve::setSameSense(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcEdgeCurve::is(Type::Enum v) const { return v == Type::IfcEdgeCurve || IfcEdge::is(v); } -Type::Enum IfcEdgeCurve::type() const { return Type::IfcEdgeCurve; } +IfcCurve* IfcEdgeCurve::EdgeGeometry() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcEdgeCurve::setEdgeGeometry(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcEdgeCurve::SameSense() const { return *data_->getArgument(3); } +void IfcEdgeCurve::setSameSense(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcEdgeCurve::declaration() const { return *IfcEdgeCurve_type; } Type::Enum IfcEdgeCurve::Class() { return Type::IfcEdgeCurve; } -IfcEdgeCurve::IfcEdgeCurve(IfcAbstractEntity* e) : IfcEdge((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEdgeCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEdgeCurve::IfcEdgeCurve(IfcVertex* v1_EdgeStart, IfcVertex* v2_EdgeEnd, IfcCurve* v3_EdgeGeometry, bool v4_SameSense) : IfcEdge((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_EdgeStart)); e->setArgument(1,(v2_EdgeEnd)); e->setArgument(2,(v3_EdgeGeometry)); e->setArgument(3,(v4_SameSense)); entity = e; EntityBuffer::Add(this); } +IfcEdgeCurve::IfcEdgeCurve(IfcAbstractEntity* e) : IfcEdge((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEdgeCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEdgeCurve::IfcEdgeCurve(IfcVertex* v1_EdgeStart, IfcVertex* v2_EdgeEnd, IfcCurve* v3_EdgeGeometry, bool v4_SameSense) : IfcEdge((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_EdgeStart)); e->setArgument(1,(v2_EdgeEnd)); e->setArgument(2,(v3_EdgeGeometry)); e->setArgument(3,(v4_SameSense)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEdgeFeature -bool IfcEdgeFeature::hasFeatureLength() const { return !entity->getArgument(8)->isNull(); } -double IfcEdgeFeature::FeatureLength() const { return *entity->getArgument(8); } -void IfcEdgeFeature::setFeatureLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcEdgeFeature::is(Type::Enum v) const { return v == Type::IfcEdgeFeature || IfcFeatureElementSubtraction::is(v); } -Type::Enum IfcEdgeFeature::type() const { return Type::IfcEdgeFeature; } +bool IfcEdgeFeature::hasFeatureLength() const { return !data_->getArgument(8)->isNull(); } +double IfcEdgeFeature::FeatureLength() const { return *data_->getArgument(8); } +void IfcEdgeFeature::setFeatureLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcEdgeFeature::declaration() const { return *IfcEdgeFeature_type; } Type::Enum IfcEdgeFeature::Class() { return Type::IfcEdgeFeature; } -IfcEdgeFeature::IfcEdgeFeature(IfcAbstractEntity* e) : IfcFeatureElementSubtraction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEdgeFeature)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEdgeFeature::IfcEdgeFeature(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength) : IfcFeatureElementSubtraction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_FeatureLength) { e->setArgument(8,(*v9_FeatureLength)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcEdgeFeature::IfcEdgeFeature(IfcAbstractEntity* e) : IfcFeatureElementSubtraction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEdgeFeature)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEdgeFeature::IfcEdgeFeature(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength) : IfcFeatureElementSubtraction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_FeatureLength) { e->setArgument(8,(*v9_FeatureLength)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEdgeLoop -IfcTemplatedEntityList< IfcOrientedEdge >::ptr IfcEdgeLoop::EdgeList() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcEdgeLoop::setEdgeList(IfcTemplatedEntityList< IfcOrientedEdge >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcEdgeLoop::is(Type::Enum v) const { return v == Type::IfcEdgeLoop || IfcLoop::is(v); } -Type::Enum IfcEdgeLoop::type() const { return Type::IfcEdgeLoop; } +IfcTemplatedEntityList< IfcOrientedEdge >::ptr IfcEdgeLoop::EdgeList() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcEdgeLoop::setEdgeList(IfcTemplatedEntityList< IfcOrientedEdge >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcEdgeLoop::declaration() const { return *IfcEdgeLoop_type; } Type::Enum IfcEdgeLoop::Class() { return Type::IfcEdgeLoop; } -IfcEdgeLoop::IfcEdgeLoop(IfcAbstractEntity* e) : IfcLoop((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEdgeLoop)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEdgeLoop::IfcEdgeLoop(IfcTemplatedEntityList< IfcOrientedEdge >::ptr v1_EdgeList) : IfcLoop((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_EdgeList)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcEdgeLoop::IfcEdgeLoop(IfcAbstractEntity* e) : IfcLoop((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEdgeLoop)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEdgeLoop::IfcEdgeLoop(IfcTemplatedEntityList< IfcOrientedEdge >::ptr v1_EdgeList) : IfcLoop((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_EdgeList)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricApplianceType -IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum IfcElectricApplianceType::PredefinedType() const { return IfcElectricApplianceTypeEnum::FromString(*entity->getArgument(9)); } -void IfcElectricApplianceType::setPredefinedType(IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcElectricApplianceTypeEnum::ToString(v)); } -bool IfcElectricApplianceType::is(Type::Enum v) const { return v == Type::IfcElectricApplianceType || IfcFlowTerminalType::is(v); } -Type::Enum IfcElectricApplianceType::type() const { return Type::IfcElectricApplianceType; } +IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum IfcElectricApplianceType::PredefinedType() const { return IfcElectricApplianceTypeEnum::FromString(*data_->getArgument(9)); } +void IfcElectricApplianceType::setPredefinedType(IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcElectricApplianceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricApplianceType::declaration() const { return *IfcElectricApplianceType_type; } Type::Enum IfcElectricApplianceType::Class() { return Type::IfcElectricApplianceType; } -IfcElectricApplianceType::IfcElectricApplianceType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricApplianceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricApplianceType::IfcElectricApplianceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricApplianceTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcElectricApplianceType::IfcElectricApplianceType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricApplianceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricApplianceType::IfcElectricApplianceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricApplianceTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricDistributionPoint -IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum IfcElectricDistributionPoint::DistributionPointFunction() const { return IfcElectricDistributionPointFunctionEnum::FromString(*entity->getArgument(8)); } -void IfcElectricDistributionPoint::setDistributionPointFunction(IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcElectricDistributionPointFunctionEnum::ToString(v)); } -bool IfcElectricDistributionPoint::hasUserDefinedFunction() const { return !entity->getArgument(9)->isNull(); } -std::string IfcElectricDistributionPoint::UserDefinedFunction() const { return *entity->getArgument(9); } -void IfcElectricDistributionPoint::setUserDefinedFunction(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcElectricDistributionPoint::is(Type::Enum v) const { return v == Type::IfcElectricDistributionPoint || IfcFlowController::is(v); } -Type::Enum IfcElectricDistributionPoint::type() const { return Type::IfcElectricDistributionPoint; } +IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum IfcElectricDistributionPoint::DistributionPointFunction() const { return IfcElectricDistributionPointFunctionEnum::FromString(*data_->getArgument(8)); } +void IfcElectricDistributionPoint::setDistributionPointFunction(IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcElectricDistributionPointFunctionEnum::ToString(v)); } +bool IfcElectricDistributionPoint::hasUserDefinedFunction() const { return !data_->getArgument(9)->isNull(); } +std::string IfcElectricDistributionPoint::UserDefinedFunction() const { return *data_->getArgument(9); } +void IfcElectricDistributionPoint::setUserDefinedFunction(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcElectricDistributionPoint::declaration() const { return *IfcElectricDistributionPoint_type; } Type::Enum IfcElectricDistributionPoint::Class() { return Type::IfcElectricDistributionPoint; } -IfcElectricDistributionPoint::IfcElectricDistributionPoint(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricDistributionPoint)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricDistributionPoint::IfcElectricDistributionPoint(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum v9_DistributionPointFunction, boost::optional< std::string > v10_UserDefinedFunction) : IfcFlowController((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_DistributionPointFunction,IfcElectricDistributionPointFunctionEnum::ToString(v9_DistributionPointFunction)); if (v10_UserDefinedFunction) { e->setArgument(9,(*v10_UserDefinedFunction)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcElectricDistributionPoint::IfcElectricDistributionPoint(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricDistributionPoint)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricDistributionPoint::IfcElectricDistributionPoint(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum v9_DistributionPointFunction, boost::optional< std::string > v10_UserDefinedFunction) : IfcFlowController((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_DistributionPointFunction,IfcElectricDistributionPointFunctionEnum::ToString(v9_DistributionPointFunction)); if (v10_UserDefinedFunction) { e->setArgument(9,(*v10_UserDefinedFunction)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricFlowStorageDeviceType -IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum IfcElectricFlowStorageDeviceType::PredefinedType() const { return IfcElectricFlowStorageDeviceTypeEnum::FromString(*entity->getArgument(9)); } -void IfcElectricFlowStorageDeviceType::setPredefinedType(IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcElectricFlowStorageDeviceTypeEnum::ToString(v)); } -bool IfcElectricFlowStorageDeviceType::is(Type::Enum v) const { return v == Type::IfcElectricFlowStorageDeviceType || IfcFlowStorageDeviceType::is(v); } -Type::Enum IfcElectricFlowStorageDeviceType::type() const { return Type::IfcElectricFlowStorageDeviceType; } +IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum IfcElectricFlowStorageDeviceType::PredefinedType() const { return IfcElectricFlowStorageDeviceTypeEnum::FromString(*data_->getArgument(9)); } +void IfcElectricFlowStorageDeviceType::setPredefinedType(IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcElectricFlowStorageDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricFlowStorageDeviceType::declaration() const { return *IfcElectricFlowStorageDeviceType_type; } Type::Enum IfcElectricFlowStorageDeviceType::Class() { return Type::IfcElectricFlowStorageDeviceType; } -IfcElectricFlowStorageDeviceType::IfcElectricFlowStorageDeviceType(IfcAbstractEntity* e) : IfcFlowStorageDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricFlowStorageDeviceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricFlowStorageDeviceType::IfcElectricFlowStorageDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum v10_PredefinedType) : IfcFlowStorageDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricFlowStorageDeviceTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcElectricFlowStorageDeviceType::IfcElectricFlowStorageDeviceType(IfcAbstractEntity* e) : IfcFlowStorageDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricFlowStorageDeviceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricFlowStorageDeviceType::IfcElectricFlowStorageDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum v10_PredefinedType) : IfcFlowStorageDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricFlowStorageDeviceTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricGeneratorType -IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum IfcElectricGeneratorType::PredefinedType() const { return IfcElectricGeneratorTypeEnum::FromString(*entity->getArgument(9)); } -void IfcElectricGeneratorType::setPredefinedType(IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcElectricGeneratorTypeEnum::ToString(v)); } -bool IfcElectricGeneratorType::is(Type::Enum v) const { return v == Type::IfcElectricGeneratorType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcElectricGeneratorType::type() const { return Type::IfcElectricGeneratorType; } +IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum IfcElectricGeneratorType::PredefinedType() const { return IfcElectricGeneratorTypeEnum::FromString(*data_->getArgument(9)); } +void IfcElectricGeneratorType::setPredefinedType(IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcElectricGeneratorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricGeneratorType::declaration() const { return *IfcElectricGeneratorType_type; } Type::Enum IfcElectricGeneratorType::Class() { return Type::IfcElectricGeneratorType; } -IfcElectricGeneratorType::IfcElectricGeneratorType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricGeneratorType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricGeneratorType::IfcElectricGeneratorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricGeneratorTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcElectricGeneratorType::IfcElectricGeneratorType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricGeneratorType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricGeneratorType::IfcElectricGeneratorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricGeneratorTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricHeaterType -IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum IfcElectricHeaterType::PredefinedType() const { return IfcElectricHeaterTypeEnum::FromString(*entity->getArgument(9)); } -void IfcElectricHeaterType::setPredefinedType(IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcElectricHeaterTypeEnum::ToString(v)); } -bool IfcElectricHeaterType::is(Type::Enum v) const { return v == Type::IfcElectricHeaterType || IfcFlowTerminalType::is(v); } -Type::Enum IfcElectricHeaterType::type() const { return Type::IfcElectricHeaterType; } +IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum IfcElectricHeaterType::PredefinedType() const { return IfcElectricHeaterTypeEnum::FromString(*data_->getArgument(9)); } +void IfcElectricHeaterType::setPredefinedType(IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcElectricHeaterTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricHeaterType::declaration() const { return *IfcElectricHeaterType_type; } Type::Enum IfcElectricHeaterType::Class() { return Type::IfcElectricHeaterType; } -IfcElectricHeaterType::IfcElectricHeaterType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricHeaterType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricHeaterType::IfcElectricHeaterType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricHeaterTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcElectricHeaterType::IfcElectricHeaterType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricHeaterType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricHeaterType::IfcElectricHeaterType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricHeaterTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricMotorType -IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum IfcElectricMotorType::PredefinedType() const { return IfcElectricMotorTypeEnum::FromString(*entity->getArgument(9)); } -void IfcElectricMotorType::setPredefinedType(IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcElectricMotorTypeEnum::ToString(v)); } -bool IfcElectricMotorType::is(Type::Enum v) const { return v == Type::IfcElectricMotorType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcElectricMotorType::type() const { return Type::IfcElectricMotorType; } +IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum IfcElectricMotorType::PredefinedType() const { return IfcElectricMotorTypeEnum::FromString(*data_->getArgument(9)); } +void IfcElectricMotorType::setPredefinedType(IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcElectricMotorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricMotorType::declaration() const { return *IfcElectricMotorType_type; } Type::Enum IfcElectricMotorType::Class() { return Type::IfcElectricMotorType; } -IfcElectricMotorType::IfcElectricMotorType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricMotorType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricMotorType::IfcElectricMotorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricMotorTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcElectricMotorType::IfcElectricMotorType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricMotorType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricMotorType::IfcElectricMotorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricMotorTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricTimeControlType -IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum IfcElectricTimeControlType::PredefinedType() const { return IfcElectricTimeControlTypeEnum::FromString(*entity->getArgument(9)); } -void IfcElectricTimeControlType::setPredefinedType(IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcElectricTimeControlTypeEnum::ToString(v)); } -bool IfcElectricTimeControlType::is(Type::Enum v) const { return v == Type::IfcElectricTimeControlType || IfcFlowControllerType::is(v); } -Type::Enum IfcElectricTimeControlType::type() const { return Type::IfcElectricTimeControlType; } +IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum IfcElectricTimeControlType::PredefinedType() const { return IfcElectricTimeControlTypeEnum::FromString(*data_->getArgument(9)); } +void IfcElectricTimeControlType::setPredefinedType(IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcElectricTimeControlTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricTimeControlType::declaration() const { return *IfcElectricTimeControlType_type; } Type::Enum IfcElectricTimeControlType::Class() { return Type::IfcElectricTimeControlType; } -IfcElectricTimeControlType::IfcElectricTimeControlType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricTimeControlType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricTimeControlType::IfcElectricTimeControlType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricTimeControlTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcElectricTimeControlType::IfcElectricTimeControlType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricTimeControlType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricTimeControlType::IfcElectricTimeControlType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElectricTimeControlTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricalBaseProperties -bool IfcElectricalBaseProperties::hasElectricCurrentType() const { return !entity->getArgument(6)->isNull(); } -IfcElectricCurrentEnum::IfcElectricCurrentEnum IfcElectricalBaseProperties::ElectricCurrentType() const { return IfcElectricCurrentEnum::FromString(*entity->getArgument(6)); } -void IfcElectricalBaseProperties::setElectricCurrentType(IfcElectricCurrentEnum::IfcElectricCurrentEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcElectricCurrentEnum::ToString(v)); } -double IfcElectricalBaseProperties::InputVoltage() const { return *entity->getArgument(7); } -void IfcElectricalBaseProperties::setInputVoltage(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -double IfcElectricalBaseProperties::InputFrequency() const { return *entity->getArgument(8); } -void IfcElectricalBaseProperties::setInputFrequency(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcElectricalBaseProperties::hasFullLoadCurrent() const { return !entity->getArgument(9)->isNull(); } -double IfcElectricalBaseProperties::FullLoadCurrent() const { return *entity->getArgument(9); } -void IfcElectricalBaseProperties::setFullLoadCurrent(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcElectricalBaseProperties::hasMinimumCircuitCurrent() const { return !entity->getArgument(10)->isNull(); } -double IfcElectricalBaseProperties::MinimumCircuitCurrent() const { return *entity->getArgument(10); } -void IfcElectricalBaseProperties::setMinimumCircuitCurrent(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcElectricalBaseProperties::hasMaximumPowerInput() const { return !entity->getArgument(11)->isNull(); } -double IfcElectricalBaseProperties::MaximumPowerInput() const { return *entity->getArgument(11); } -void IfcElectricalBaseProperties::setMaximumPowerInput(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcElectricalBaseProperties::hasRatedPowerInput() const { return !entity->getArgument(12)->isNull(); } -double IfcElectricalBaseProperties::RatedPowerInput() const { return *entity->getArgument(12); } -void IfcElectricalBaseProperties::setRatedPowerInput(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -int IfcElectricalBaseProperties::InputPhase() const { return *entity->getArgument(13); } -void IfcElectricalBaseProperties::setInputPhase(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcElectricalBaseProperties::is(Type::Enum v) const { return v == Type::IfcElectricalBaseProperties || IfcEnergyProperties::is(v); } -Type::Enum IfcElectricalBaseProperties::type() const { return Type::IfcElectricalBaseProperties; } +bool IfcElectricalBaseProperties::hasElectricCurrentType() const { return !data_->getArgument(6)->isNull(); } +IfcElectricCurrentEnum::IfcElectricCurrentEnum IfcElectricalBaseProperties::ElectricCurrentType() const { return IfcElectricCurrentEnum::FromString(*data_->getArgument(6)); } +void IfcElectricalBaseProperties::setElectricCurrentType(IfcElectricCurrentEnum::IfcElectricCurrentEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcElectricCurrentEnum::ToString(v)); } +double IfcElectricalBaseProperties::InputVoltage() const { return *data_->getArgument(7); } +void IfcElectricalBaseProperties::setInputVoltage(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +double IfcElectricalBaseProperties::InputFrequency() const { return *data_->getArgument(8); } +void IfcElectricalBaseProperties::setInputFrequency(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcElectricalBaseProperties::hasFullLoadCurrent() const { return !data_->getArgument(9)->isNull(); } +double IfcElectricalBaseProperties::FullLoadCurrent() const { return *data_->getArgument(9); } +void IfcElectricalBaseProperties::setFullLoadCurrent(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcElectricalBaseProperties::hasMinimumCircuitCurrent() const { return !data_->getArgument(10)->isNull(); } +double IfcElectricalBaseProperties::MinimumCircuitCurrent() const { return *data_->getArgument(10); } +void IfcElectricalBaseProperties::setMinimumCircuitCurrent(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcElectricalBaseProperties::hasMaximumPowerInput() const { return !data_->getArgument(11)->isNull(); } +double IfcElectricalBaseProperties::MaximumPowerInput() const { return *data_->getArgument(11); } +void IfcElectricalBaseProperties::setMaximumPowerInput(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcElectricalBaseProperties::hasRatedPowerInput() const { return !data_->getArgument(12)->isNull(); } +double IfcElectricalBaseProperties::RatedPowerInput() const { return *data_->getArgument(12); } +void IfcElectricalBaseProperties::setRatedPowerInput(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +int IfcElectricalBaseProperties::InputPhase() const { return *data_->getArgument(13); } +void IfcElectricalBaseProperties::setInputPhase(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } + + +const IfcParse::entity& IfcElectricalBaseProperties::declaration() const { return *IfcElectricalBaseProperties_type; } Type::Enum IfcElectricalBaseProperties::Class() { return Type::IfcElectricalBaseProperties; } -IfcElectricalBaseProperties::IfcElectricalBaseProperties(IfcAbstractEntity* e) : IfcEnergyProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricalBaseProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricalBaseProperties::IfcElectricalBaseProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcEnergySequenceEnum::IfcEnergySequenceEnum > v5_EnergySequence, boost::optional< std::string > v6_UserDefinedEnergySequence, boost::optional< IfcElectricCurrentEnum::IfcElectricCurrentEnum > v7_ElectricCurrentType, double v8_InputVoltage, double v9_InputFrequency, boost::optional< double > v10_FullLoadCurrent, boost::optional< double > v11_MinimumCircuitCurrent, boost::optional< double > v12_MaximumPowerInput, boost::optional< double > v13_RatedPowerInput, int v14_InputPhase) : IfcEnergyProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_EnergySequence) { e->setArgument(4,*v5_EnergySequence,IfcEnergySequenceEnum::ToString(*v5_EnergySequence)); } else { e->setArgument(4); } if (v6_UserDefinedEnergySequence) { e->setArgument(5,(*v6_UserDefinedEnergySequence)); } else { e->setArgument(5); } if (v7_ElectricCurrentType) { e->setArgument(6,*v7_ElectricCurrentType,IfcElectricCurrentEnum::ToString(*v7_ElectricCurrentType)); } else { e->setArgument(6); } e->setArgument(7,(v8_InputVoltage)); e->setArgument(8,(v9_InputFrequency)); if (v10_FullLoadCurrent) { e->setArgument(9,(*v10_FullLoadCurrent)); } else { e->setArgument(9); } if (v11_MinimumCircuitCurrent) { e->setArgument(10,(*v11_MinimumCircuitCurrent)); } else { e->setArgument(10); } if (v12_MaximumPowerInput) { e->setArgument(11,(*v12_MaximumPowerInput)); } else { e->setArgument(11); } if (v13_RatedPowerInput) { e->setArgument(12,(*v13_RatedPowerInput)); } else { e->setArgument(12); } e->setArgument(13,(v14_InputPhase)); entity = e; EntityBuffer::Add(this); } +IfcElectricalBaseProperties::IfcElectricalBaseProperties(IfcAbstractEntity* e) : IfcEnergyProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricalBaseProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricalBaseProperties::IfcElectricalBaseProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcEnergySequenceEnum::IfcEnergySequenceEnum > v5_EnergySequence, boost::optional< std::string > v6_UserDefinedEnergySequence, boost::optional< IfcElectricCurrentEnum::IfcElectricCurrentEnum > v7_ElectricCurrentType, double v8_InputVoltage, double v9_InputFrequency, boost::optional< double > v10_FullLoadCurrent, boost::optional< double > v11_MinimumCircuitCurrent, boost::optional< double > v12_MaximumPowerInput, boost::optional< double > v13_RatedPowerInput, int v14_InputPhase) : IfcEnergyProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_EnergySequence) { e->setArgument(4,*v5_EnergySequence,IfcEnergySequenceEnum::ToString(*v5_EnergySequence)); } else { e->setArgument(4); } if (v6_UserDefinedEnergySequence) { e->setArgument(5,(*v6_UserDefinedEnergySequence)); } else { e->setArgument(5); } if (v7_ElectricCurrentType) { e->setArgument(6,*v7_ElectricCurrentType,IfcElectricCurrentEnum::ToString(*v7_ElectricCurrentType)); } else { e->setArgument(6); } e->setArgument(7,(v8_InputVoltage)); e->setArgument(8,(v9_InputFrequency)); if (v10_FullLoadCurrent) { e->setArgument(9,(*v10_FullLoadCurrent)); } else { e->setArgument(9); } if (v11_MinimumCircuitCurrent) { e->setArgument(10,(*v11_MinimumCircuitCurrent)); } else { e->setArgument(10); } if (v12_MaximumPowerInput) { e->setArgument(11,(*v12_MaximumPowerInput)); } else { e->setArgument(11); } if (v13_RatedPowerInput) { e->setArgument(12,(*v13_RatedPowerInput)); } else { e->setArgument(12); } e->setArgument(13,(v14_InputPhase)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricalCircuit -bool IfcElectricalCircuit::is(Type::Enum v) const { return v == Type::IfcElectricalCircuit || IfcSystem::is(v); } -Type::Enum IfcElectricalCircuit::type() const { return Type::IfcElectricalCircuit; } + + +const IfcParse::entity& IfcElectricalCircuit::declaration() const { return *IfcElectricalCircuit_type; } Type::Enum IfcElectricalCircuit::Class() { return Type::IfcElectricalCircuit; } -IfcElectricalCircuit::IfcElectricalCircuit(IfcAbstractEntity* e) : IfcSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricalCircuit)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricalCircuit::IfcElectricalCircuit(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcSystem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcElectricalCircuit::IfcElectricalCircuit(IfcAbstractEntity* e) : IfcSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricalCircuit)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricalCircuit::IfcElectricalCircuit(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcSystem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricalElement -bool IfcElectricalElement::is(Type::Enum v) const { return v == Type::IfcElectricalElement || IfcElement::is(v); } -Type::Enum IfcElectricalElement::type() const { return Type::IfcElectricalElement; } + + +const IfcParse::entity& IfcElectricalElement::declaration() const { return *IfcElectricalElement_type; } Type::Enum IfcElectricalElement::Class() { return Type::IfcElectricalElement; } -IfcElectricalElement::IfcElectricalElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricalElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricalElement::IfcElectricalElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcElectricalElement::IfcElectricalElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricalElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricalElement::IfcElectricalElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElement -bool IfcElement::hasTag() const { return !entity->getArgument(7)->isNull(); } -std::string IfcElement::Tag() const { return *entity->getArgument(7); } -void IfcElement::setTag(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcRelConnectsStructuralElement::list::ptr IfcElement::HasStructuralMember() const { return entity->getInverse(Type::IfcRelConnectsStructuralElement, 4)->as(); } -IfcRelFillsElement::list::ptr IfcElement::FillsVoids() const { return entity->getInverse(Type::IfcRelFillsElement, 5)->as(); } -IfcRelConnectsElements::list::ptr IfcElement::ConnectedTo() const { return entity->getInverse(Type::IfcRelConnectsElements, 5)->as(); } -IfcRelCoversBldgElements::list::ptr IfcElement::HasCoverings() const { return entity->getInverse(Type::IfcRelCoversBldgElements, 4)->as(); } -IfcRelProjectsElement::list::ptr IfcElement::HasProjections() const { return entity->getInverse(Type::IfcRelProjectsElement, 4)->as(); } -IfcRelReferencedInSpatialStructure::list::ptr IfcElement::ReferencedInStructures() const { return entity->getInverse(Type::IfcRelReferencedInSpatialStructure, 4)->as(); } -IfcRelConnectsPortToElement::list::ptr IfcElement::HasPorts() const { return entity->getInverse(Type::IfcRelConnectsPortToElement, 5)->as(); } -IfcRelVoidsElement::list::ptr IfcElement::HasOpenings() const { return entity->getInverse(Type::IfcRelVoidsElement, 4)->as(); } -IfcRelConnectsWithRealizingElements::list::ptr IfcElement::IsConnectionRealization() const { return entity->getInverse(Type::IfcRelConnectsWithRealizingElements, 7)->as(); } -IfcRelSpaceBoundary::list::ptr IfcElement::ProvidesBoundaries() const { return entity->getInverse(Type::IfcRelSpaceBoundary, 5)->as(); } -IfcRelConnectsElements::list::ptr IfcElement::ConnectedFrom() const { return entity->getInverse(Type::IfcRelConnectsElements, 6)->as(); } -IfcRelContainedInSpatialStructure::list::ptr IfcElement::ContainedInStructure() const { return entity->getInverse(Type::IfcRelContainedInSpatialStructure, 4)->as(); } -bool IfcElement::is(Type::Enum v) const { return v == Type::IfcElement || IfcProduct::is(v); } -Type::Enum IfcElement::type() const { return Type::IfcElement; } +bool IfcElement::hasTag() const { return !data_->getArgument(7)->isNull(); } +std::string IfcElement::Tag() const { return *data_->getArgument(7); } +void IfcElement::setTag(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + +IfcRelConnectsStructuralElement::list::ptr IfcElement::HasStructuralMember() const { return data_->getInverse(Type::IfcRelConnectsStructuralElement, 4)->as(); } +IfcRelFillsElement::list::ptr IfcElement::FillsVoids() const { return data_->getInverse(Type::IfcRelFillsElement, 5)->as(); } +IfcRelConnectsElements::list::ptr IfcElement::ConnectedTo() const { return data_->getInverse(Type::IfcRelConnectsElements, 5)->as(); } +IfcRelCoversBldgElements::list::ptr IfcElement::HasCoverings() const { return data_->getInverse(Type::IfcRelCoversBldgElements, 4)->as(); } +IfcRelProjectsElement::list::ptr IfcElement::HasProjections() const { return data_->getInverse(Type::IfcRelProjectsElement, 4)->as(); } +IfcRelReferencedInSpatialStructure::list::ptr IfcElement::ReferencedInStructures() const { return data_->getInverse(Type::IfcRelReferencedInSpatialStructure, 4)->as(); } +IfcRelConnectsPortToElement::list::ptr IfcElement::HasPorts() const { return data_->getInverse(Type::IfcRelConnectsPortToElement, 5)->as(); } +IfcRelVoidsElement::list::ptr IfcElement::HasOpenings() const { return data_->getInverse(Type::IfcRelVoidsElement, 4)->as(); } +IfcRelConnectsWithRealizingElements::list::ptr IfcElement::IsConnectionRealization() const { return data_->getInverse(Type::IfcRelConnectsWithRealizingElements, 7)->as(); } +IfcRelSpaceBoundary::list::ptr IfcElement::ProvidesBoundaries() const { return data_->getInverse(Type::IfcRelSpaceBoundary, 5)->as(); } +IfcRelConnectsElements::list::ptr IfcElement::ConnectedFrom() const { return data_->getInverse(Type::IfcRelConnectsElements, 6)->as(); } +IfcRelContainedInSpatialStructure::list::ptr IfcElement::ContainedInStructure() const { return data_->getInverse(Type::IfcRelContainedInSpatialStructure, 4)->as(); } + +const IfcParse::entity& IfcElement::declaration() const { return *IfcElement_type; } Type::Enum IfcElement::Class() { return Type::IfcElement; } -IfcElement::IfcElement(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElement::IfcElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcElement::IfcElement(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElement::IfcElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElementAssembly -bool IfcElementAssembly::hasAssemblyPlace() const { return !entity->getArgument(8)->isNull(); } -IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum IfcElementAssembly::AssemblyPlace() const { return IfcAssemblyPlaceEnum::FromString(*entity->getArgument(8)); } -void IfcElementAssembly::setAssemblyPlace(IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcAssemblyPlaceEnum::ToString(v)); } -IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum IfcElementAssembly::PredefinedType() const { return IfcElementAssemblyTypeEnum::FromString(*entity->getArgument(9)); } -void IfcElementAssembly::setPredefinedType(IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcElementAssemblyTypeEnum::ToString(v)); } -bool IfcElementAssembly::is(Type::Enum v) const { return v == Type::IfcElementAssembly || IfcElement::is(v); } -Type::Enum IfcElementAssembly::type() const { return Type::IfcElementAssembly; } +bool IfcElementAssembly::hasAssemblyPlace() const { return !data_->getArgument(8)->isNull(); } +IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum IfcElementAssembly::AssemblyPlace() const { return IfcAssemblyPlaceEnum::FromString(*data_->getArgument(8)); } +void IfcElementAssembly::setAssemblyPlace(IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcAssemblyPlaceEnum::ToString(v)); } +IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum IfcElementAssembly::PredefinedType() const { return IfcElementAssemblyTypeEnum::FromString(*data_->getArgument(9)); } +void IfcElementAssembly::setPredefinedType(IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcElementAssemblyTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElementAssembly::declaration() const { return *IfcElementAssembly_type; } Type::Enum IfcElementAssembly::Class() { return Type::IfcElementAssembly; } -IfcElementAssembly::IfcElementAssembly(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementAssembly)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElementAssembly::IfcElementAssembly(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum > v9_AssemblyPlace, IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum v10_PredefinedType) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_AssemblyPlace) { e->setArgument(8,*v9_AssemblyPlace,IfcAssemblyPlaceEnum::ToString(*v9_AssemblyPlace)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElementAssemblyTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcElementAssembly::IfcElementAssembly(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementAssembly)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElementAssembly::IfcElementAssembly(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum > v9_AssemblyPlace, IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum v10_PredefinedType) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_AssemblyPlace) { e->setArgument(8,*v9_AssemblyPlace,IfcAssemblyPlaceEnum::ToString(*v9_AssemblyPlace)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcElementAssemblyTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElementComponent -bool IfcElementComponent::is(Type::Enum v) const { return v == Type::IfcElementComponent || IfcElement::is(v); } -Type::Enum IfcElementComponent::type() const { return Type::IfcElementComponent; } + + +const IfcParse::entity& IfcElementComponent::declaration() const { return *IfcElementComponent_type; } Type::Enum IfcElementComponent::Class() { return Type::IfcElementComponent; } -IfcElementComponent::IfcElementComponent(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementComponent)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElementComponent::IfcElementComponent(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcElementComponent::IfcElementComponent(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementComponent)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElementComponent::IfcElementComponent(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElementComponentType -bool IfcElementComponentType::is(Type::Enum v) const { return v == Type::IfcElementComponentType || IfcElementType::is(v); } -Type::Enum IfcElementComponentType::type() const { return Type::IfcElementComponentType; } + + +const IfcParse::entity& IfcElementComponentType::declaration() const { return *IfcElementComponentType_type; } Type::Enum IfcElementComponentType::Class() { return Type::IfcElementComponentType; } -IfcElementComponentType::IfcElementComponentType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementComponentType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElementComponentType::IfcElementComponentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcElementComponentType::IfcElementComponentType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementComponentType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElementComponentType::IfcElementComponentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElementQuantity -bool IfcElementQuantity::hasMethodOfMeasurement() const { return !entity->getArgument(4)->isNull(); } -std::string IfcElementQuantity::MethodOfMeasurement() const { return *entity->getArgument(4); } -void IfcElementQuantity::setMethodOfMeasurement(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr IfcElementQuantity::Quantities() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcElementQuantity::setQuantities(IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v->generalize()); } -bool IfcElementQuantity::is(Type::Enum v) const { return v == Type::IfcElementQuantity || IfcPropertySetDefinition::is(v); } -Type::Enum IfcElementQuantity::type() const { return Type::IfcElementQuantity; } +bool IfcElementQuantity::hasMethodOfMeasurement() const { return !data_->getArgument(4)->isNull(); } +std::string IfcElementQuantity::MethodOfMeasurement() const { return *data_->getArgument(4); } +void IfcElementQuantity::setMethodOfMeasurement(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr IfcElementQuantity::Quantities() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcElementQuantity::setQuantities(IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v->generalize()); } + + +const IfcParse::entity& IfcElementQuantity::declaration() const { return *IfcElementQuantity_type; } Type::Enum IfcElementQuantity::Class() { return Type::IfcElementQuantity; } -IfcElementQuantity::IfcElementQuantity(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementQuantity)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElementQuantity::IfcElementQuantity(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_MethodOfMeasurement, IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v6_Quantities) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_MethodOfMeasurement) { e->setArgument(4,(*v5_MethodOfMeasurement)); } else { e->setArgument(4); } e->setArgument(5,(v6_Quantities)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcElementQuantity::IfcElementQuantity(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementQuantity)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElementQuantity::IfcElementQuantity(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_MethodOfMeasurement, IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v6_Quantities) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_MethodOfMeasurement) { e->setArgument(4,(*v5_MethodOfMeasurement)); } else { e->setArgument(4); } e->setArgument(5,(v6_Quantities)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElementType -bool IfcElementType::hasElementType() const { return !entity->getArgument(8)->isNull(); } -std::string IfcElementType::ElementType() const { return *entity->getArgument(8); } -void IfcElementType::setElementType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcElementType::is(Type::Enum v) const { return v == Type::IfcElementType || IfcTypeProduct::is(v); } -Type::Enum IfcElementType::type() const { return Type::IfcElementType; } +bool IfcElementType::hasElementType() const { return !data_->getArgument(8)->isNull(); } +std::string IfcElementType::ElementType() const { return *data_->getArgument(8); } +void IfcElementType::setElementType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcElementType::declaration() const { return *IfcElementType_type; } Type::Enum IfcElementType::Class() { return Type::IfcElementType; } -IfcElementType::IfcElementType(IfcAbstractEntity* e) : IfcTypeProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElementType::IfcElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcTypeProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcElementType::IfcElementType(IfcAbstractEntity* e) : IfcTypeProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElementType::IfcElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcTypeProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElementarySurface -IfcAxis2Placement3D* IfcElementarySurface::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcElementarySurface::setPosition(IfcAxis2Placement3D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcElementarySurface::is(Type::Enum v) const { return v == Type::IfcElementarySurface || IfcSurface::is(v); } -Type::Enum IfcElementarySurface::type() const { return Type::IfcElementarySurface; } +IfcAxis2Placement3D* IfcElementarySurface::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcElementarySurface::setPosition(IfcAxis2Placement3D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcElementarySurface::declaration() const { return *IfcElementarySurface_type; } Type::Enum IfcElementarySurface::Class() { return Type::IfcElementarySurface; } -IfcElementarySurface::IfcElementarySurface(IfcAbstractEntity* e) : IfcSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementarySurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElementarySurface::IfcElementarySurface(IfcAxis2Placement3D* v1_Position) : IfcSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); entity = e; EntityBuffer::Add(this); } +IfcElementarySurface::IfcElementarySurface(IfcAbstractEntity* e) : IfcSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementarySurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElementarySurface::IfcElementarySurface(IfcAxis2Placement3D* v1_Position) : IfcSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEllipse -double IfcEllipse::SemiAxis1() const { return *entity->getArgument(1); } -void IfcEllipse::setSemiAxis1(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcEllipse::SemiAxis2() const { return *entity->getArgument(2); } -void IfcEllipse::setSemiAxis2(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcEllipse::is(Type::Enum v) const { return v == Type::IfcEllipse || IfcConic::is(v); } -Type::Enum IfcEllipse::type() const { return Type::IfcEllipse; } +double IfcEllipse::SemiAxis1() const { return *data_->getArgument(1); } +void IfcEllipse::setSemiAxis1(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcEllipse::SemiAxis2() const { return *data_->getArgument(2); } +void IfcEllipse::setSemiAxis2(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcEllipse::declaration() const { return *IfcEllipse_type; } Type::Enum IfcEllipse::Class() { return Type::IfcEllipse; } -IfcEllipse::IfcEllipse(IfcAbstractEntity* e) : IfcConic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEllipse)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEllipse::IfcEllipse(IfcAxis2Placement* v1_Position, double v2_SemiAxis1, double v3_SemiAxis2) : IfcConic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_SemiAxis1)); e->setArgument(2,(v3_SemiAxis2)); entity = e; EntityBuffer::Add(this); } +IfcEllipse::IfcEllipse(IfcAbstractEntity* e) : IfcConic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEllipse)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEllipse::IfcEllipse(IfcAxis2Placement* v1_Position, double v2_SemiAxis1, double v3_SemiAxis2) : IfcConic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_SemiAxis1)); e->setArgument(2,(v3_SemiAxis2)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEllipseProfileDef -double IfcEllipseProfileDef::SemiAxis1() const { return *entity->getArgument(3); } -void IfcEllipseProfileDef::setSemiAxis1(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcEllipseProfileDef::SemiAxis2() const { return *entity->getArgument(4); } -void IfcEllipseProfileDef::setSemiAxis2(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcEllipseProfileDef::is(Type::Enum v) const { return v == Type::IfcEllipseProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcEllipseProfileDef::type() const { return Type::IfcEllipseProfileDef; } +double IfcEllipseProfileDef::SemiAxis1() const { return *data_->getArgument(3); } +void IfcEllipseProfileDef::setSemiAxis1(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcEllipseProfileDef::SemiAxis2() const { return *data_->getArgument(4); } +void IfcEllipseProfileDef::setSemiAxis2(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcEllipseProfileDef::declaration() const { return *IfcEllipseProfileDef_type; } Type::Enum IfcEllipseProfileDef::Class() { return Type::IfcEllipseProfileDef; } -IfcEllipseProfileDef::IfcEllipseProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEllipseProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEllipseProfileDef::IfcEllipseProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_SemiAxis1, double v5_SemiAxis2) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_SemiAxis1)); e->setArgument(4,(v5_SemiAxis2)); entity = e; EntityBuffer::Add(this); } +IfcEllipseProfileDef::IfcEllipseProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEllipseProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEllipseProfileDef::IfcEllipseProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_SemiAxis1, double v5_SemiAxis2) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_SemiAxis1)); e->setArgument(4,(v5_SemiAxis2)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEnergyConversionDevice -bool IfcEnergyConversionDevice::is(Type::Enum v) const { return v == Type::IfcEnergyConversionDevice || IfcDistributionFlowElement::is(v); } -Type::Enum IfcEnergyConversionDevice::type() const { return Type::IfcEnergyConversionDevice; } + + +const IfcParse::entity& IfcEnergyConversionDevice::declaration() const { return *IfcEnergyConversionDevice_type; } Type::Enum IfcEnergyConversionDevice::Class() { return Type::IfcEnergyConversionDevice; } -IfcEnergyConversionDevice::IfcEnergyConversionDevice(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEnergyConversionDevice)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEnergyConversionDevice::IfcEnergyConversionDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcEnergyConversionDevice::IfcEnergyConversionDevice(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEnergyConversionDevice)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEnergyConversionDevice::IfcEnergyConversionDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEnergyConversionDeviceType -bool IfcEnergyConversionDeviceType::is(Type::Enum v) const { return v == Type::IfcEnergyConversionDeviceType || IfcDistributionFlowElementType::is(v); } -Type::Enum IfcEnergyConversionDeviceType::type() const { return Type::IfcEnergyConversionDeviceType; } + + +const IfcParse::entity& IfcEnergyConversionDeviceType::declaration() const { return *IfcEnergyConversionDeviceType_type; } Type::Enum IfcEnergyConversionDeviceType::Class() { return Type::IfcEnergyConversionDeviceType; } -IfcEnergyConversionDeviceType::IfcEnergyConversionDeviceType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEnergyConversionDeviceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEnergyConversionDeviceType::IfcEnergyConversionDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcEnergyConversionDeviceType::IfcEnergyConversionDeviceType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEnergyConversionDeviceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEnergyConversionDeviceType::IfcEnergyConversionDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEnergyProperties -bool IfcEnergyProperties::hasEnergySequence() const { return !entity->getArgument(4)->isNull(); } -IfcEnergySequenceEnum::IfcEnergySequenceEnum IfcEnergyProperties::EnergySequence() const { return IfcEnergySequenceEnum::FromString(*entity->getArgument(4)); } -void IfcEnergyProperties::setEnergySequence(IfcEnergySequenceEnum::IfcEnergySequenceEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcEnergySequenceEnum::ToString(v)); } -bool IfcEnergyProperties::hasUserDefinedEnergySequence() const { return !entity->getArgument(5)->isNull(); } -std::string IfcEnergyProperties::UserDefinedEnergySequence() const { return *entity->getArgument(5); } -void IfcEnergyProperties::setUserDefinedEnergySequence(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcEnergyProperties::is(Type::Enum v) const { return v == Type::IfcEnergyProperties || IfcPropertySetDefinition::is(v); } -Type::Enum IfcEnergyProperties::type() const { return Type::IfcEnergyProperties; } +bool IfcEnergyProperties::hasEnergySequence() const { return !data_->getArgument(4)->isNull(); } +IfcEnergySequenceEnum::IfcEnergySequenceEnum IfcEnergyProperties::EnergySequence() const { return IfcEnergySequenceEnum::FromString(*data_->getArgument(4)); } +void IfcEnergyProperties::setEnergySequence(IfcEnergySequenceEnum::IfcEnergySequenceEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcEnergySequenceEnum::ToString(v)); } +bool IfcEnergyProperties::hasUserDefinedEnergySequence() const { return !data_->getArgument(5)->isNull(); } +std::string IfcEnergyProperties::UserDefinedEnergySequence() const { return *data_->getArgument(5); } +void IfcEnergyProperties::setUserDefinedEnergySequence(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcEnergyProperties::declaration() const { return *IfcEnergyProperties_type; } Type::Enum IfcEnergyProperties::Class() { return Type::IfcEnergyProperties; } -IfcEnergyProperties::IfcEnergyProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEnergyProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEnergyProperties::IfcEnergyProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcEnergySequenceEnum::IfcEnergySequenceEnum > v5_EnergySequence, boost::optional< std::string > v6_UserDefinedEnergySequence) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_EnergySequence) { e->setArgument(4,*v5_EnergySequence,IfcEnergySequenceEnum::ToString(*v5_EnergySequence)); } else { e->setArgument(4); } if (v6_UserDefinedEnergySequence) { e->setArgument(5,(*v6_UserDefinedEnergySequence)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcEnergyProperties::IfcEnergyProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEnergyProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEnergyProperties::IfcEnergyProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcEnergySequenceEnum::IfcEnergySequenceEnum > v5_EnergySequence, boost::optional< std::string > v6_UserDefinedEnergySequence) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_EnergySequence) { e->setArgument(4,*v5_EnergySequence,IfcEnergySequenceEnum::ToString(*v5_EnergySequence)); } else { e->setArgument(4); } if (v6_UserDefinedEnergySequence) { e->setArgument(5,(*v6_UserDefinedEnergySequence)); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEnvironmentalImpactValue -std::string IfcEnvironmentalImpactValue::ImpactType() const { return *entity->getArgument(6); } -void IfcEnvironmentalImpactValue::setImpactType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum IfcEnvironmentalImpactValue::Category() const { return IfcEnvironmentalImpactCategoryEnum::FromString(*entity->getArgument(7)); } -void IfcEnvironmentalImpactValue::setCategory(IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcEnvironmentalImpactCategoryEnum::ToString(v)); } -bool IfcEnvironmentalImpactValue::hasUserDefinedCategory() const { return !entity->getArgument(8)->isNull(); } -std::string IfcEnvironmentalImpactValue::UserDefinedCategory() const { return *entity->getArgument(8); } -void IfcEnvironmentalImpactValue::setUserDefinedCategory(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcEnvironmentalImpactValue::is(Type::Enum v) const { return v == Type::IfcEnvironmentalImpactValue || IfcAppliedValue::is(v); } -Type::Enum IfcEnvironmentalImpactValue::type() const { return Type::IfcEnvironmentalImpactValue; } +std::string IfcEnvironmentalImpactValue::ImpactType() const { return *data_->getArgument(6); } +void IfcEnvironmentalImpactValue::setImpactType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum IfcEnvironmentalImpactValue::Category() const { return IfcEnvironmentalImpactCategoryEnum::FromString(*data_->getArgument(7)); } +void IfcEnvironmentalImpactValue::setCategory(IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcEnvironmentalImpactCategoryEnum::ToString(v)); } +bool IfcEnvironmentalImpactValue::hasUserDefinedCategory() const { return !data_->getArgument(8)->isNull(); } +std::string IfcEnvironmentalImpactValue::UserDefinedCategory() const { return *data_->getArgument(8); } +void IfcEnvironmentalImpactValue::setUserDefinedCategory(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcEnvironmentalImpactValue::declaration() const { return *IfcEnvironmentalImpactValue_type; } Type::Enum IfcEnvironmentalImpactValue::Class() { return Type::IfcEnvironmentalImpactValue; } -IfcEnvironmentalImpactValue::IfcEnvironmentalImpactValue(IfcAbstractEntity* e) : IfcAppliedValue((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEnvironmentalImpactValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEnvironmentalImpactValue::IfcEnvironmentalImpactValue(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcAppliedValueSelect* v3_AppliedValue, IfcMeasureWithUnit* v4_UnitBasis, IfcDateTimeSelect* v5_ApplicableDate, IfcDateTimeSelect* v6_FixedUntilDate, std::string v7_ImpactType, IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum v8_Category, boost::optional< std::string > v9_UserDefinedCategory) : IfcAppliedValue((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_AppliedValue)); e->setArgument(3,(v4_UnitBasis)); e->setArgument(4,(v5_ApplicableDate)); e->setArgument(5,(v6_FixedUntilDate)); e->setArgument(6,(v7_ImpactType)); e->setArgument(7,v8_Category,IfcEnvironmentalImpactCategoryEnum::ToString(v8_Category)); if (v9_UserDefinedCategory) { e->setArgument(8,(*v9_UserDefinedCategory)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcEnvironmentalImpactValue::IfcEnvironmentalImpactValue(IfcAbstractEntity* e) : IfcAppliedValue((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEnvironmentalImpactValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEnvironmentalImpactValue::IfcEnvironmentalImpactValue(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcAppliedValueSelect* v3_AppliedValue, IfcMeasureWithUnit* v4_UnitBasis, IfcDateTimeSelect* v5_ApplicableDate, IfcDateTimeSelect* v6_FixedUntilDate, std::string v7_ImpactType, IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum v8_Category, boost::optional< std::string > v9_UserDefinedCategory) : IfcAppliedValue((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_AppliedValue)); e->setArgument(3,(v4_UnitBasis)); e->setArgument(4,(v5_ApplicableDate)); e->setArgument(5,(v6_FixedUntilDate)); e->setArgument(6,(v7_ImpactType)); e->setArgument(7,v8_Category,IfcEnvironmentalImpactCategoryEnum::ToString(v8_Category)); if (v9_UserDefinedCategory) { e->setArgument(8,(*v9_UserDefinedCategory)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEquipmentElement -bool IfcEquipmentElement::is(Type::Enum v) const { return v == Type::IfcEquipmentElement || IfcElement::is(v); } -Type::Enum IfcEquipmentElement::type() const { return Type::IfcEquipmentElement; } + + +const IfcParse::entity& IfcEquipmentElement::declaration() const { return *IfcEquipmentElement_type; } Type::Enum IfcEquipmentElement::Class() { return Type::IfcEquipmentElement; } -IfcEquipmentElement::IfcEquipmentElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEquipmentElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEquipmentElement::IfcEquipmentElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcEquipmentElement::IfcEquipmentElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEquipmentElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEquipmentElement::IfcEquipmentElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEquipmentStandard -bool IfcEquipmentStandard::is(Type::Enum v) const { return v == Type::IfcEquipmentStandard || IfcControl::is(v); } -Type::Enum IfcEquipmentStandard::type() const { return Type::IfcEquipmentStandard; } + + +const IfcParse::entity& IfcEquipmentStandard::declaration() const { return *IfcEquipmentStandard_type; } Type::Enum IfcEquipmentStandard::Class() { return Type::IfcEquipmentStandard; } -IfcEquipmentStandard::IfcEquipmentStandard(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEquipmentStandard)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEquipmentStandard::IfcEquipmentStandard(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcEquipmentStandard::IfcEquipmentStandard(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEquipmentStandard)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEquipmentStandard::IfcEquipmentStandard(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEvaporativeCoolerType -IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum IfcEvaporativeCoolerType::PredefinedType() const { return IfcEvaporativeCoolerTypeEnum::FromString(*entity->getArgument(9)); } -void IfcEvaporativeCoolerType::setPredefinedType(IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcEvaporativeCoolerTypeEnum::ToString(v)); } -bool IfcEvaporativeCoolerType::is(Type::Enum v) const { return v == Type::IfcEvaporativeCoolerType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcEvaporativeCoolerType::type() const { return Type::IfcEvaporativeCoolerType; } +IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum IfcEvaporativeCoolerType::PredefinedType() const { return IfcEvaporativeCoolerTypeEnum::FromString(*data_->getArgument(9)); } +void IfcEvaporativeCoolerType::setPredefinedType(IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcEvaporativeCoolerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcEvaporativeCoolerType::declaration() const { return *IfcEvaporativeCoolerType_type; } Type::Enum IfcEvaporativeCoolerType::Class() { return Type::IfcEvaporativeCoolerType; } -IfcEvaporativeCoolerType::IfcEvaporativeCoolerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEvaporativeCoolerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEvaporativeCoolerType::IfcEvaporativeCoolerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcEvaporativeCoolerTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcEvaporativeCoolerType::IfcEvaporativeCoolerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEvaporativeCoolerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEvaporativeCoolerType::IfcEvaporativeCoolerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcEvaporativeCoolerTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEvaporatorType -IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum IfcEvaporatorType::PredefinedType() const { return IfcEvaporatorTypeEnum::FromString(*entity->getArgument(9)); } -void IfcEvaporatorType::setPredefinedType(IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcEvaporatorTypeEnum::ToString(v)); } -bool IfcEvaporatorType::is(Type::Enum v) const { return v == Type::IfcEvaporatorType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcEvaporatorType::type() const { return Type::IfcEvaporatorType; } +IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum IfcEvaporatorType::PredefinedType() const { return IfcEvaporatorTypeEnum::FromString(*data_->getArgument(9)); } +void IfcEvaporatorType::setPredefinedType(IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcEvaporatorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcEvaporatorType::declaration() const { return *IfcEvaporatorType_type; } Type::Enum IfcEvaporatorType::Class() { return Type::IfcEvaporatorType; } -IfcEvaporatorType::IfcEvaporatorType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEvaporatorType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEvaporatorType::IfcEvaporatorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcEvaporatorTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcEvaporatorType::IfcEvaporatorType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEvaporatorType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEvaporatorType::IfcEvaporatorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcEvaporatorTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExtendedMaterialProperties -IfcTemplatedEntityList< IfcProperty >::ptr IfcExtendedMaterialProperties::ExtendedProperties() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcExtendedMaterialProperties::setExtendedProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcExtendedMaterialProperties::hasDescription() const { return !entity->getArgument(2)->isNull(); } -std::string IfcExtendedMaterialProperties::Description() const { return *entity->getArgument(2); } -void IfcExtendedMaterialProperties::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -std::string IfcExtendedMaterialProperties::Name() const { return *entity->getArgument(3); } -void IfcExtendedMaterialProperties::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcExtendedMaterialProperties::is(Type::Enum v) const { return v == Type::IfcExtendedMaterialProperties || IfcMaterialProperties::is(v); } -Type::Enum IfcExtendedMaterialProperties::type() const { return Type::IfcExtendedMaterialProperties; } +IfcTemplatedEntityList< IfcProperty >::ptr IfcExtendedMaterialProperties::ExtendedProperties() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcExtendedMaterialProperties::setExtendedProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +bool IfcExtendedMaterialProperties::hasDescription() const { return !data_->getArgument(2)->isNull(); } +std::string IfcExtendedMaterialProperties::Description() const { return *data_->getArgument(2); } +void IfcExtendedMaterialProperties::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +std::string IfcExtendedMaterialProperties::Name() const { return *data_->getArgument(3); } +void IfcExtendedMaterialProperties::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcExtendedMaterialProperties::declaration() const { return *IfcExtendedMaterialProperties_type; } Type::Enum IfcExtendedMaterialProperties::Class() { return Type::IfcExtendedMaterialProperties; } -IfcExtendedMaterialProperties::IfcExtendedMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExtendedMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExtendedMaterialProperties::IfcExtendedMaterialProperties(IfcMaterial* v1_Material, IfcTemplatedEntityList< IfcProperty >::ptr v2_ExtendedProperties, boost::optional< std::string > v3_Description, std::string v4_Name) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); e->setArgument(1,(v2_ExtendedProperties)->generalize()); if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } e->setArgument(3,(v4_Name)); entity = e; EntityBuffer::Add(this); } +IfcExtendedMaterialProperties::IfcExtendedMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExtendedMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExtendedMaterialProperties::IfcExtendedMaterialProperties(IfcMaterial* v1_Material, IfcTemplatedEntityList< IfcProperty >::ptr v2_ExtendedProperties, boost::optional< std::string > v3_Description, std::string v4_Name) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); e->setArgument(1,(v2_ExtendedProperties)->generalize()); if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } e->setArgument(3,(v4_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExternalReference -bool IfcExternalReference::hasLocation() const { return !entity->getArgument(0)->isNull(); } -std::string IfcExternalReference::Location() const { return *entity->getArgument(0); } -void IfcExternalReference::setLocation(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcExternalReference::hasItemReference() const { return !entity->getArgument(1)->isNull(); } -std::string IfcExternalReference::ItemReference() const { return *entity->getArgument(1); } -void IfcExternalReference::setItemReference(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcExternalReference::hasName() const { return !entity->getArgument(2)->isNull(); } -std::string IfcExternalReference::Name() const { return *entity->getArgument(2); } -void IfcExternalReference::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcExternalReference::is(Type::Enum v) const { return v == Type::IfcExternalReference; } -Type::Enum IfcExternalReference::type() const { return Type::IfcExternalReference; } +bool IfcExternalReference::hasLocation() const { return !data_->getArgument(0)->isNull(); } +std::string IfcExternalReference::Location() const { return *data_->getArgument(0); } +void IfcExternalReference::setLocation(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcExternalReference::hasItemReference() const { return !data_->getArgument(1)->isNull(); } +std::string IfcExternalReference::ItemReference() const { return *data_->getArgument(1); } +void IfcExternalReference::setItemReference(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcExternalReference::hasName() const { return !data_->getArgument(2)->isNull(); } +std::string IfcExternalReference::Name() const { return *data_->getArgument(2); } +void IfcExternalReference::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcExternalReference::declaration() const { return *IfcExternalReference_type; } Type::Enum IfcExternalReference::Class() { return Type::IfcExternalReference; } -IfcExternalReference::IfcExternalReference(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcExternalReference)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExternalReference::IfcExternalReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcExternalReference::IfcExternalReference(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcExternalReference)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExternalReference::IfcExternalReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExternallyDefinedHatchStyle -bool IfcExternallyDefinedHatchStyle::is(Type::Enum v) const { return v == Type::IfcExternallyDefinedHatchStyle || IfcExternalReference::is(v); } -Type::Enum IfcExternallyDefinedHatchStyle::type() const { return Type::IfcExternallyDefinedHatchStyle; } + + +const IfcParse::entity& IfcExternallyDefinedHatchStyle::declaration() const { return *IfcExternallyDefinedHatchStyle_type; } Type::Enum IfcExternallyDefinedHatchStyle::Class() { return Type::IfcExternallyDefinedHatchStyle; } -IfcExternallyDefinedHatchStyle::IfcExternallyDefinedHatchStyle(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternallyDefinedHatchStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExternallyDefinedHatchStyle::IfcExternallyDefinedHatchStyle(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcExternallyDefinedHatchStyle::IfcExternallyDefinedHatchStyle(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternallyDefinedHatchStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExternallyDefinedHatchStyle::IfcExternallyDefinedHatchStyle(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExternallyDefinedSurfaceStyle -bool IfcExternallyDefinedSurfaceStyle::is(Type::Enum v) const { return v == Type::IfcExternallyDefinedSurfaceStyle || IfcExternalReference::is(v); } -Type::Enum IfcExternallyDefinedSurfaceStyle::type() const { return Type::IfcExternallyDefinedSurfaceStyle; } + + +const IfcParse::entity& IfcExternallyDefinedSurfaceStyle::declaration() const { return *IfcExternallyDefinedSurfaceStyle_type; } Type::Enum IfcExternallyDefinedSurfaceStyle::Class() { return Type::IfcExternallyDefinedSurfaceStyle; } -IfcExternallyDefinedSurfaceStyle::IfcExternallyDefinedSurfaceStyle(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternallyDefinedSurfaceStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExternallyDefinedSurfaceStyle::IfcExternallyDefinedSurfaceStyle(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcExternallyDefinedSurfaceStyle::IfcExternallyDefinedSurfaceStyle(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternallyDefinedSurfaceStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExternallyDefinedSurfaceStyle::IfcExternallyDefinedSurfaceStyle(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExternallyDefinedSymbol -bool IfcExternallyDefinedSymbol::is(Type::Enum v) const { return v == Type::IfcExternallyDefinedSymbol || IfcExternalReference::is(v); } -Type::Enum IfcExternallyDefinedSymbol::type() const { return Type::IfcExternallyDefinedSymbol; } + + +const IfcParse::entity& IfcExternallyDefinedSymbol::declaration() const { return *IfcExternallyDefinedSymbol_type; } Type::Enum IfcExternallyDefinedSymbol::Class() { return Type::IfcExternallyDefinedSymbol; } -IfcExternallyDefinedSymbol::IfcExternallyDefinedSymbol(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternallyDefinedSymbol)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExternallyDefinedSymbol::IfcExternallyDefinedSymbol(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcExternallyDefinedSymbol::IfcExternallyDefinedSymbol(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternallyDefinedSymbol)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExternallyDefinedSymbol::IfcExternallyDefinedSymbol(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExternallyDefinedTextFont -bool IfcExternallyDefinedTextFont::is(Type::Enum v) const { return v == Type::IfcExternallyDefinedTextFont || IfcExternalReference::is(v); } -Type::Enum IfcExternallyDefinedTextFont::type() const { return Type::IfcExternallyDefinedTextFont; } + + +const IfcParse::entity& IfcExternallyDefinedTextFont::declaration() const { return *IfcExternallyDefinedTextFont_type; } Type::Enum IfcExternallyDefinedTextFont::Class() { return Type::IfcExternallyDefinedTextFont; } -IfcExternallyDefinedTextFont::IfcExternallyDefinedTextFont(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternallyDefinedTextFont)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExternallyDefinedTextFont::IfcExternallyDefinedTextFont(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcExternallyDefinedTextFont::IfcExternallyDefinedTextFont(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternallyDefinedTextFont)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExternallyDefinedTextFont::IfcExternallyDefinedTextFont(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExtrudedAreaSolid -IfcDirection* IfcExtrudedAreaSolid::ExtrudedDirection() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcExtrudedAreaSolid::setExtrudedDirection(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -double IfcExtrudedAreaSolid::Depth() const { return *entity->getArgument(3); } -void IfcExtrudedAreaSolid::setDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcExtrudedAreaSolid::is(Type::Enum v) const { return v == Type::IfcExtrudedAreaSolid || IfcSweptAreaSolid::is(v); } -Type::Enum IfcExtrudedAreaSolid::type() const { return Type::IfcExtrudedAreaSolid; } +IfcDirection* IfcExtrudedAreaSolid::ExtrudedDirection() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcExtrudedAreaSolid::setExtrudedDirection(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +double IfcExtrudedAreaSolid::Depth() const { return *data_->getArgument(3); } +void IfcExtrudedAreaSolid::setDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcExtrudedAreaSolid::declaration() const { return *IfcExtrudedAreaSolid_type; } Type::Enum IfcExtrudedAreaSolid::Class() { return Type::IfcExtrudedAreaSolid; } -IfcExtrudedAreaSolid::IfcExtrudedAreaSolid(IfcAbstractEntity* e) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExtrudedAreaSolid)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExtrudedAreaSolid::IfcExtrudedAreaSolid(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcDirection* v3_ExtrudedDirection, double v4_Depth) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptArea)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_ExtrudedDirection)); e->setArgument(3,(v4_Depth)); entity = e; EntityBuffer::Add(this); } +IfcExtrudedAreaSolid::IfcExtrudedAreaSolid(IfcAbstractEntity* e) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExtrudedAreaSolid)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExtrudedAreaSolid::IfcExtrudedAreaSolid(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcDirection* v3_ExtrudedDirection, double v4_Depth) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptArea)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_ExtrudedDirection)); e->setArgument(3,(v4_Depth)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFace -IfcTemplatedEntityList< IfcFaceBound >::ptr IfcFace::Bounds() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcFace::setBounds(IfcTemplatedEntityList< IfcFaceBound >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcFace::is(Type::Enum v) const { return v == Type::IfcFace || IfcTopologicalRepresentationItem::is(v); } -Type::Enum IfcFace::type() const { return Type::IfcFace; } +IfcTemplatedEntityList< IfcFaceBound >::ptr IfcFace::Bounds() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcFace::setBounds(IfcTemplatedEntityList< IfcFaceBound >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcFace::declaration() const { return *IfcFace_type; } Type::Enum IfcFace::Class() { return Type::IfcFace; } -IfcFace::IfcFace(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFace)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFace::IfcFace(IfcTemplatedEntityList< IfcFaceBound >::ptr v1_Bounds) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Bounds)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcFace::IfcFace(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFace)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFace::IfcFace(IfcTemplatedEntityList< IfcFaceBound >::ptr v1_Bounds) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Bounds)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFaceBasedSurfaceModel -IfcTemplatedEntityList< IfcConnectedFaceSet >::ptr IfcFaceBasedSurfaceModel::FbsmFaces() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcFaceBasedSurfaceModel::setFbsmFaces(IfcTemplatedEntityList< IfcConnectedFaceSet >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcFaceBasedSurfaceModel::is(Type::Enum v) const { return v == Type::IfcFaceBasedSurfaceModel || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcFaceBasedSurfaceModel::type() const { return Type::IfcFaceBasedSurfaceModel; } +IfcTemplatedEntityList< IfcConnectedFaceSet >::ptr IfcFaceBasedSurfaceModel::FbsmFaces() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcFaceBasedSurfaceModel::setFbsmFaces(IfcTemplatedEntityList< IfcConnectedFaceSet >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcFaceBasedSurfaceModel::declaration() const { return *IfcFaceBasedSurfaceModel_type; } Type::Enum IfcFaceBasedSurfaceModel::Class() { return Type::IfcFaceBasedSurfaceModel; } -IfcFaceBasedSurfaceModel::IfcFaceBasedSurfaceModel(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFaceBasedSurfaceModel)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFaceBasedSurfaceModel::IfcFaceBasedSurfaceModel(IfcTemplatedEntityList< IfcConnectedFaceSet >::ptr v1_FbsmFaces) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_FbsmFaces)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcFaceBasedSurfaceModel::IfcFaceBasedSurfaceModel(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFaceBasedSurfaceModel)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFaceBasedSurfaceModel::IfcFaceBasedSurfaceModel(IfcTemplatedEntityList< IfcConnectedFaceSet >::ptr v1_FbsmFaces) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_FbsmFaces)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFaceBound -IfcLoop* IfcFaceBound::Bound() const { return (IfcLoop*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcFaceBound::setBound(IfcLoop* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcFaceBound::Orientation() const { return *entity->getArgument(1); } -void IfcFaceBound::setOrientation(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcFaceBound::is(Type::Enum v) const { return v == Type::IfcFaceBound || IfcTopologicalRepresentationItem::is(v); } -Type::Enum IfcFaceBound::type() const { return Type::IfcFaceBound; } +IfcLoop* IfcFaceBound::Bound() const { return (IfcLoop*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcFaceBound::setBound(IfcLoop* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcFaceBound::Orientation() const { return *data_->getArgument(1); } +void IfcFaceBound::setOrientation(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcFaceBound::declaration() const { return *IfcFaceBound_type; } Type::Enum IfcFaceBound::Class() { return Type::IfcFaceBound; } -IfcFaceBound::IfcFaceBound(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFaceBound)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFaceBound::IfcFaceBound(IfcLoop* v1_Bound, bool v2_Orientation) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Bound)); e->setArgument(1,(v2_Orientation)); entity = e; EntityBuffer::Add(this); } +IfcFaceBound::IfcFaceBound(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFaceBound)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFaceBound::IfcFaceBound(IfcLoop* v1_Bound, bool v2_Orientation) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Bound)); e->setArgument(1,(v2_Orientation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFaceOuterBound -bool IfcFaceOuterBound::is(Type::Enum v) const { return v == Type::IfcFaceOuterBound || IfcFaceBound::is(v); } -Type::Enum IfcFaceOuterBound::type() const { return Type::IfcFaceOuterBound; } + + +const IfcParse::entity& IfcFaceOuterBound::declaration() const { return *IfcFaceOuterBound_type; } Type::Enum IfcFaceOuterBound::Class() { return Type::IfcFaceOuterBound; } -IfcFaceOuterBound::IfcFaceOuterBound(IfcAbstractEntity* e) : IfcFaceBound((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFaceOuterBound)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFaceOuterBound::IfcFaceOuterBound(IfcLoop* v1_Bound, bool v2_Orientation) : IfcFaceBound((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Bound)); e->setArgument(1,(v2_Orientation)); entity = e; EntityBuffer::Add(this); } +IfcFaceOuterBound::IfcFaceOuterBound(IfcAbstractEntity* e) : IfcFaceBound((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFaceOuterBound)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFaceOuterBound::IfcFaceOuterBound(IfcLoop* v1_Bound, bool v2_Orientation) : IfcFaceBound((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Bound)); e->setArgument(1,(v2_Orientation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFaceSurface -IfcSurface* IfcFaceSurface::FaceSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcFaceSurface::setFaceSurface(IfcSurface* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcFaceSurface::SameSense() const { return *entity->getArgument(2); } -void IfcFaceSurface::setSameSense(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcFaceSurface::is(Type::Enum v) const { return v == Type::IfcFaceSurface || IfcFace::is(v); } -Type::Enum IfcFaceSurface::type() const { return Type::IfcFaceSurface; } +IfcSurface* IfcFaceSurface::FaceSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcFaceSurface::setFaceSurface(IfcSurface* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcFaceSurface::SameSense() const { return *data_->getArgument(2); } +void IfcFaceSurface::setSameSense(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcFaceSurface::declaration() const { return *IfcFaceSurface_type; } Type::Enum IfcFaceSurface::Class() { return Type::IfcFaceSurface; } -IfcFaceSurface::IfcFaceSurface(IfcAbstractEntity* e) : IfcFace((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFaceSurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFaceSurface::IfcFaceSurface(IfcTemplatedEntityList< IfcFaceBound >::ptr v1_Bounds, IfcSurface* v2_FaceSurface, bool v3_SameSense) : IfcFace((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Bounds)->generalize()); e->setArgument(1,(v2_FaceSurface)); e->setArgument(2,(v3_SameSense)); entity = e; EntityBuffer::Add(this); } +IfcFaceSurface::IfcFaceSurface(IfcAbstractEntity* e) : IfcFace((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFaceSurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFaceSurface::IfcFaceSurface(IfcTemplatedEntityList< IfcFaceBound >::ptr v1_Bounds, IfcSurface* v2_FaceSurface, bool v3_SameSense) : IfcFace((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Bounds)->generalize()); e->setArgument(1,(v2_FaceSurface)); e->setArgument(2,(v3_SameSense)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFacetedBrep -bool IfcFacetedBrep::is(Type::Enum v) const { return v == Type::IfcFacetedBrep || IfcManifoldSolidBrep::is(v); } -Type::Enum IfcFacetedBrep::type() const { return Type::IfcFacetedBrep; } + + +const IfcParse::entity& IfcFacetedBrep::declaration() const { return *IfcFacetedBrep_type; } Type::Enum IfcFacetedBrep::Class() { return Type::IfcFacetedBrep; } -IfcFacetedBrep::IfcFacetedBrep(IfcAbstractEntity* e) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFacetedBrep)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFacetedBrep::IfcFacetedBrep(IfcClosedShell* v1_Outer) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Outer)); entity = e; EntityBuffer::Add(this); } +IfcFacetedBrep::IfcFacetedBrep(IfcAbstractEntity* e) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFacetedBrep)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFacetedBrep::IfcFacetedBrep(IfcClosedShell* v1_Outer) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Outer)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFacetedBrepWithVoids -IfcTemplatedEntityList< IfcClosedShell >::ptr IfcFacetedBrepWithVoids::Voids() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcFacetedBrepWithVoids::setVoids(IfcTemplatedEntityList< IfcClosedShell >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcFacetedBrepWithVoids::is(Type::Enum v) const { return v == Type::IfcFacetedBrepWithVoids || IfcManifoldSolidBrep::is(v); } -Type::Enum IfcFacetedBrepWithVoids::type() const { return Type::IfcFacetedBrepWithVoids; } +IfcTemplatedEntityList< IfcClosedShell >::ptr IfcFacetedBrepWithVoids::Voids() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcFacetedBrepWithVoids::setVoids(IfcTemplatedEntityList< IfcClosedShell >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } + + +const IfcParse::entity& IfcFacetedBrepWithVoids::declaration() const { return *IfcFacetedBrepWithVoids_type; } Type::Enum IfcFacetedBrepWithVoids::Class() { return Type::IfcFacetedBrepWithVoids; } -IfcFacetedBrepWithVoids::IfcFacetedBrepWithVoids(IfcAbstractEntity* e) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFacetedBrepWithVoids)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFacetedBrepWithVoids::IfcFacetedBrepWithVoids(IfcClosedShell* v1_Outer, IfcTemplatedEntityList< IfcClosedShell >::ptr v2_Voids) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Outer)); e->setArgument(1,(v2_Voids)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcFacetedBrepWithVoids::IfcFacetedBrepWithVoids(IfcAbstractEntity* e) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFacetedBrepWithVoids)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFacetedBrepWithVoids::IfcFacetedBrepWithVoids(IfcClosedShell* v1_Outer, IfcTemplatedEntityList< IfcClosedShell >::ptr v2_Voids) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Outer)); e->setArgument(1,(v2_Voids)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFailureConnectionCondition -bool IfcFailureConnectionCondition::hasTensionFailureX() const { return !entity->getArgument(1)->isNull(); } -double IfcFailureConnectionCondition::TensionFailureX() const { return *entity->getArgument(1); } -void IfcFailureConnectionCondition::setTensionFailureX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcFailureConnectionCondition::hasTensionFailureY() const { return !entity->getArgument(2)->isNull(); } -double IfcFailureConnectionCondition::TensionFailureY() const { return *entity->getArgument(2); } -void IfcFailureConnectionCondition::setTensionFailureY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcFailureConnectionCondition::hasTensionFailureZ() const { return !entity->getArgument(3)->isNull(); } -double IfcFailureConnectionCondition::TensionFailureZ() const { return *entity->getArgument(3); } -void IfcFailureConnectionCondition::setTensionFailureZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcFailureConnectionCondition::hasCompressionFailureX() const { return !entity->getArgument(4)->isNull(); } -double IfcFailureConnectionCondition::CompressionFailureX() const { return *entity->getArgument(4); } -void IfcFailureConnectionCondition::setCompressionFailureX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcFailureConnectionCondition::hasCompressionFailureY() const { return !entity->getArgument(5)->isNull(); } -double IfcFailureConnectionCondition::CompressionFailureY() const { return *entity->getArgument(5); } -void IfcFailureConnectionCondition::setCompressionFailureY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcFailureConnectionCondition::hasCompressionFailureZ() const { return !entity->getArgument(6)->isNull(); } -double IfcFailureConnectionCondition::CompressionFailureZ() const { return *entity->getArgument(6); } -void IfcFailureConnectionCondition::setCompressionFailureZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcFailureConnectionCondition::is(Type::Enum v) const { return v == Type::IfcFailureConnectionCondition || IfcStructuralConnectionCondition::is(v); } -Type::Enum IfcFailureConnectionCondition::type() const { return Type::IfcFailureConnectionCondition; } +bool IfcFailureConnectionCondition::hasTensionFailureX() const { return !data_->getArgument(1)->isNull(); } +double IfcFailureConnectionCondition::TensionFailureX() const { return *data_->getArgument(1); } +void IfcFailureConnectionCondition::setTensionFailureX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcFailureConnectionCondition::hasTensionFailureY() const { return !data_->getArgument(2)->isNull(); } +double IfcFailureConnectionCondition::TensionFailureY() const { return *data_->getArgument(2); } +void IfcFailureConnectionCondition::setTensionFailureY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcFailureConnectionCondition::hasTensionFailureZ() const { return !data_->getArgument(3)->isNull(); } +double IfcFailureConnectionCondition::TensionFailureZ() const { return *data_->getArgument(3); } +void IfcFailureConnectionCondition::setTensionFailureZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcFailureConnectionCondition::hasCompressionFailureX() const { return !data_->getArgument(4)->isNull(); } +double IfcFailureConnectionCondition::CompressionFailureX() const { return *data_->getArgument(4); } +void IfcFailureConnectionCondition::setCompressionFailureX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcFailureConnectionCondition::hasCompressionFailureY() const { return !data_->getArgument(5)->isNull(); } +double IfcFailureConnectionCondition::CompressionFailureY() const { return *data_->getArgument(5); } +void IfcFailureConnectionCondition::setCompressionFailureY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcFailureConnectionCondition::hasCompressionFailureZ() const { return !data_->getArgument(6)->isNull(); } +double IfcFailureConnectionCondition::CompressionFailureZ() const { return *data_->getArgument(6); } +void IfcFailureConnectionCondition::setCompressionFailureZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcFailureConnectionCondition::declaration() const { return *IfcFailureConnectionCondition_type; } Type::Enum IfcFailureConnectionCondition::Class() { return Type::IfcFailureConnectionCondition; } -IfcFailureConnectionCondition::IfcFailureConnectionCondition(IfcAbstractEntity* e) : IfcStructuralConnectionCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFailureConnectionCondition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFailureConnectionCondition::IfcFailureConnectionCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_TensionFailureX, boost::optional< double > v3_TensionFailureY, boost::optional< double > v4_TensionFailureZ, boost::optional< double > v5_CompressionFailureX, boost::optional< double > v6_CompressionFailureY, boost::optional< double > v7_CompressionFailureZ) : IfcStructuralConnectionCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_TensionFailureX) { e->setArgument(1,(*v2_TensionFailureX)); } else { e->setArgument(1); } if (v3_TensionFailureY) { e->setArgument(2,(*v3_TensionFailureY)); } else { e->setArgument(2); } if (v4_TensionFailureZ) { e->setArgument(3,(*v4_TensionFailureZ)); } else { e->setArgument(3); } if (v5_CompressionFailureX) { e->setArgument(4,(*v5_CompressionFailureX)); } else { e->setArgument(4); } if (v6_CompressionFailureY) { e->setArgument(5,(*v6_CompressionFailureY)); } else { e->setArgument(5); } if (v7_CompressionFailureZ) { e->setArgument(6,(*v7_CompressionFailureZ)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcFailureConnectionCondition::IfcFailureConnectionCondition(IfcAbstractEntity* e) : IfcStructuralConnectionCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFailureConnectionCondition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFailureConnectionCondition::IfcFailureConnectionCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_TensionFailureX, boost::optional< double > v3_TensionFailureY, boost::optional< double > v4_TensionFailureZ, boost::optional< double > v5_CompressionFailureX, boost::optional< double > v6_CompressionFailureY, boost::optional< double > v7_CompressionFailureZ) : IfcStructuralConnectionCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_TensionFailureX) { e->setArgument(1,(*v2_TensionFailureX)); } else { e->setArgument(1); } if (v3_TensionFailureY) { e->setArgument(2,(*v3_TensionFailureY)); } else { e->setArgument(2); } if (v4_TensionFailureZ) { e->setArgument(3,(*v4_TensionFailureZ)); } else { e->setArgument(3); } if (v5_CompressionFailureX) { e->setArgument(4,(*v5_CompressionFailureX)); } else { e->setArgument(4); } if (v6_CompressionFailureY) { e->setArgument(5,(*v6_CompressionFailureY)); } else { e->setArgument(5); } if (v7_CompressionFailureZ) { e->setArgument(6,(*v7_CompressionFailureZ)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFanType -IfcFanTypeEnum::IfcFanTypeEnum IfcFanType::PredefinedType() const { return IfcFanTypeEnum::FromString(*entity->getArgument(9)); } -void IfcFanType::setPredefinedType(IfcFanTypeEnum::IfcFanTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcFanTypeEnum::ToString(v)); } -bool IfcFanType::is(Type::Enum v) const { return v == Type::IfcFanType || IfcFlowMovingDeviceType::is(v); } -Type::Enum IfcFanType::type() const { return Type::IfcFanType; } +IfcFanTypeEnum::IfcFanTypeEnum IfcFanType::PredefinedType() const { return IfcFanTypeEnum::FromString(*data_->getArgument(9)); } +void IfcFanType::setPredefinedType(IfcFanTypeEnum::IfcFanTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcFanTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFanType::declaration() const { return *IfcFanType_type; } Type::Enum IfcFanType::Class() { return Type::IfcFanType; } -IfcFanType::IfcFanType(IfcAbstractEntity* e) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFanType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFanType::IfcFanType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFanTypeEnum::IfcFanTypeEnum v10_PredefinedType) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcFanTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcFanType::IfcFanType(IfcAbstractEntity* e) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFanType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFanType::IfcFanType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFanTypeEnum::IfcFanTypeEnum v10_PredefinedType) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcFanTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFastener -bool IfcFastener::is(Type::Enum v) const { return v == Type::IfcFastener || IfcElementComponent::is(v); } -Type::Enum IfcFastener::type() const { return Type::IfcFastener; } + + +const IfcParse::entity& IfcFastener::declaration() const { return *IfcFastener_type; } Type::Enum IfcFastener::Class() { return Type::IfcFastener; } -IfcFastener::IfcFastener(IfcAbstractEntity* e) : IfcElementComponent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFastener)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFastener::IfcFastener(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElementComponent((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFastener::IfcFastener(IfcAbstractEntity* e) : IfcElementComponent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFastener)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFastener::IfcFastener(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElementComponent((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFastenerType -bool IfcFastenerType::is(Type::Enum v) const { return v == Type::IfcFastenerType || IfcElementComponentType::is(v); } -Type::Enum IfcFastenerType::type() const { return Type::IfcFastenerType; } + + +const IfcParse::entity& IfcFastenerType::declaration() const { return *IfcFastenerType_type; } Type::Enum IfcFastenerType::Class() { return Type::IfcFastenerType; } -IfcFastenerType::IfcFastenerType(IfcAbstractEntity* e) : IfcElementComponentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFastenerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFastenerType::IfcFastenerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementComponentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFastenerType::IfcFastenerType(IfcAbstractEntity* e) : IfcElementComponentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFastenerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFastenerType::IfcFastenerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementComponentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFeatureElement -bool IfcFeatureElement::is(Type::Enum v) const { return v == Type::IfcFeatureElement || IfcElement::is(v); } -Type::Enum IfcFeatureElement::type() const { return Type::IfcFeatureElement; } + + +const IfcParse::entity& IfcFeatureElement::declaration() const { return *IfcFeatureElement_type; } Type::Enum IfcFeatureElement::Class() { return Type::IfcFeatureElement; } -IfcFeatureElement::IfcFeatureElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFeatureElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFeatureElement::IfcFeatureElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFeatureElement::IfcFeatureElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFeatureElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFeatureElement::IfcFeatureElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFeatureElementAddition -IfcRelProjectsElement::list::ptr IfcFeatureElementAddition::ProjectsElements() const { return entity->getInverse(Type::IfcRelProjectsElement, 5)->as(); } -bool IfcFeatureElementAddition::is(Type::Enum v) const { return v == Type::IfcFeatureElementAddition || IfcFeatureElement::is(v); } -Type::Enum IfcFeatureElementAddition::type() const { return Type::IfcFeatureElementAddition; } + +IfcRelProjectsElement::list::ptr IfcFeatureElementAddition::ProjectsElements() const { return data_->getInverse(Type::IfcRelProjectsElement, 5)->as(); } + +const IfcParse::entity& IfcFeatureElementAddition::declaration() const { return *IfcFeatureElementAddition_type; } Type::Enum IfcFeatureElementAddition::Class() { return Type::IfcFeatureElementAddition; } -IfcFeatureElementAddition::IfcFeatureElementAddition(IfcAbstractEntity* e) : IfcFeatureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFeatureElementAddition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFeatureElementAddition::IfcFeatureElementAddition(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFeatureElementAddition::IfcFeatureElementAddition(IfcAbstractEntity* e) : IfcFeatureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFeatureElementAddition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFeatureElementAddition::IfcFeatureElementAddition(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFeatureElementSubtraction -IfcRelVoidsElement::list::ptr IfcFeatureElementSubtraction::VoidsElements() const { return entity->getInverse(Type::IfcRelVoidsElement, 5)->as(); } -bool IfcFeatureElementSubtraction::is(Type::Enum v) const { return v == Type::IfcFeatureElementSubtraction || IfcFeatureElement::is(v); } -Type::Enum IfcFeatureElementSubtraction::type() const { return Type::IfcFeatureElementSubtraction; } + +IfcRelVoidsElement::list::ptr IfcFeatureElementSubtraction::VoidsElements() const { return data_->getInverse(Type::IfcRelVoidsElement, 5)->as(); } + +const IfcParse::entity& IfcFeatureElementSubtraction::declaration() const { return *IfcFeatureElementSubtraction_type; } Type::Enum IfcFeatureElementSubtraction::Class() { return Type::IfcFeatureElementSubtraction; } -IfcFeatureElementSubtraction::IfcFeatureElementSubtraction(IfcAbstractEntity* e) : IfcFeatureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFeatureElementSubtraction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFeatureElementSubtraction::IfcFeatureElementSubtraction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFeatureElementSubtraction::IfcFeatureElementSubtraction(IfcAbstractEntity* e) : IfcFeatureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFeatureElementSubtraction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFeatureElementSubtraction::IfcFeatureElementSubtraction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFillAreaStyle -IfcEntityList::ptr IfcFillAreaStyle::FillStyles() const { return *entity->getArgument(1); } -void IfcFillAreaStyle::setFillStyles(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcFillAreaStyle::is(Type::Enum v) const { return v == Type::IfcFillAreaStyle || IfcPresentationStyle::is(v); } -Type::Enum IfcFillAreaStyle::type() const { return Type::IfcFillAreaStyle; } +IfcEntityList::ptr IfcFillAreaStyle::FillStyles() const { return *data_->getArgument(1); } +void IfcFillAreaStyle::setFillStyles(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcFillAreaStyle::declaration() const { return *IfcFillAreaStyle_type; } Type::Enum IfcFillAreaStyle::Class() { return Type::IfcFillAreaStyle; } -IfcFillAreaStyle::IfcFillAreaStyle(IfcAbstractEntity* e) : IfcPresentationStyle((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFillAreaStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFillAreaStyle::IfcFillAreaStyle(boost::optional< std::string > v1_Name, IfcEntityList::ptr v2_FillStyles) : IfcPresentationStyle((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_FillStyles)); entity = e; EntityBuffer::Add(this); } +IfcFillAreaStyle::IfcFillAreaStyle(IfcAbstractEntity* e) : IfcPresentationStyle((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFillAreaStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFillAreaStyle::IfcFillAreaStyle(boost::optional< std::string > v1_Name, IfcEntityList::ptr v2_FillStyles) : IfcPresentationStyle((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_FillStyles)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFillAreaStyleHatching -IfcCurveStyle* IfcFillAreaStyleHatching::HatchLineAppearance() const { return (IfcCurveStyle*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcFillAreaStyleHatching::setHatchLineAppearance(IfcCurveStyle* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcHatchLineDistanceSelect* IfcFillAreaStyleHatching::StartOfNextHatchLine() const { return (IfcHatchLineDistanceSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcFillAreaStyleHatching::setStartOfNextHatchLine(IfcHatchLineDistanceSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcFillAreaStyleHatching::hasPointOfReferenceHatchLine() const { return !entity->getArgument(2)->isNull(); } -IfcCartesianPoint* IfcFillAreaStyleHatching::PointOfReferenceHatchLine() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcFillAreaStyleHatching::setPointOfReferenceHatchLine(IfcCartesianPoint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcFillAreaStyleHatching::hasPatternStart() const { return !entity->getArgument(3)->isNull(); } -IfcCartesianPoint* IfcFillAreaStyleHatching::PatternStart() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcFillAreaStyleHatching::setPatternStart(IfcCartesianPoint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcFillAreaStyleHatching::HatchLineAngle() const { return *entity->getArgument(4); } -void IfcFillAreaStyleHatching::setHatchLineAngle(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcFillAreaStyleHatching::is(Type::Enum v) const { return v == Type::IfcFillAreaStyleHatching || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcFillAreaStyleHatching::type() const { return Type::IfcFillAreaStyleHatching; } +IfcCurveStyle* IfcFillAreaStyleHatching::HatchLineAppearance() const { return (IfcCurveStyle*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcFillAreaStyleHatching::setHatchLineAppearance(IfcCurveStyle* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcHatchLineDistanceSelect* IfcFillAreaStyleHatching::StartOfNextHatchLine() const { return (IfcHatchLineDistanceSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcFillAreaStyleHatching::setStartOfNextHatchLine(IfcHatchLineDistanceSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcFillAreaStyleHatching::hasPointOfReferenceHatchLine() const { return !data_->getArgument(2)->isNull(); } +IfcCartesianPoint* IfcFillAreaStyleHatching::PointOfReferenceHatchLine() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcFillAreaStyleHatching::setPointOfReferenceHatchLine(IfcCartesianPoint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcFillAreaStyleHatching::hasPatternStart() const { return !data_->getArgument(3)->isNull(); } +IfcCartesianPoint* IfcFillAreaStyleHatching::PatternStart() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcFillAreaStyleHatching::setPatternStart(IfcCartesianPoint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcFillAreaStyleHatching::HatchLineAngle() const { return *data_->getArgument(4); } +void IfcFillAreaStyleHatching::setHatchLineAngle(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcFillAreaStyleHatching::declaration() const { return *IfcFillAreaStyleHatching_type; } Type::Enum IfcFillAreaStyleHatching::Class() { return Type::IfcFillAreaStyleHatching; } -IfcFillAreaStyleHatching::IfcFillAreaStyleHatching(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFillAreaStyleHatching)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFillAreaStyleHatching::IfcFillAreaStyleHatching(IfcCurveStyle* v1_HatchLineAppearance, IfcHatchLineDistanceSelect* v2_StartOfNextHatchLine, IfcCartesianPoint* v3_PointOfReferenceHatchLine, IfcCartesianPoint* v4_PatternStart, double v5_HatchLineAngle) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_HatchLineAppearance)); e->setArgument(1,(v2_StartOfNextHatchLine)); e->setArgument(2,(v3_PointOfReferenceHatchLine)); e->setArgument(3,(v4_PatternStart)); e->setArgument(4,(v5_HatchLineAngle)); entity = e; EntityBuffer::Add(this); } +IfcFillAreaStyleHatching::IfcFillAreaStyleHatching(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFillAreaStyleHatching)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFillAreaStyleHatching::IfcFillAreaStyleHatching(IfcCurveStyle* v1_HatchLineAppearance, IfcHatchLineDistanceSelect* v2_StartOfNextHatchLine, IfcCartesianPoint* v3_PointOfReferenceHatchLine, IfcCartesianPoint* v4_PatternStart, double v5_HatchLineAngle) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_HatchLineAppearance)); e->setArgument(1,(v2_StartOfNextHatchLine)); e->setArgument(2,(v3_PointOfReferenceHatchLine)); e->setArgument(3,(v4_PatternStart)); e->setArgument(4,(v5_HatchLineAngle)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFillAreaStyleTileSymbolWithStyle -IfcAnnotationSymbolOccurrence* IfcFillAreaStyleTileSymbolWithStyle::Symbol() const { return (IfcAnnotationSymbolOccurrence*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcFillAreaStyleTileSymbolWithStyle::setSymbol(IfcAnnotationSymbolOccurrence* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcFillAreaStyleTileSymbolWithStyle::is(Type::Enum v) const { return v == Type::IfcFillAreaStyleTileSymbolWithStyle || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcFillAreaStyleTileSymbolWithStyle::type() const { return Type::IfcFillAreaStyleTileSymbolWithStyle; } +IfcAnnotationSymbolOccurrence* IfcFillAreaStyleTileSymbolWithStyle::Symbol() const { return (IfcAnnotationSymbolOccurrence*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcFillAreaStyleTileSymbolWithStyle::setSymbol(IfcAnnotationSymbolOccurrence* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcFillAreaStyleTileSymbolWithStyle::declaration() const { return *IfcFillAreaStyleTileSymbolWithStyle_type; } Type::Enum IfcFillAreaStyleTileSymbolWithStyle::Class() { return Type::IfcFillAreaStyleTileSymbolWithStyle; } -IfcFillAreaStyleTileSymbolWithStyle::IfcFillAreaStyleTileSymbolWithStyle(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFillAreaStyleTileSymbolWithStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFillAreaStyleTileSymbolWithStyle::IfcFillAreaStyleTileSymbolWithStyle(IfcAnnotationSymbolOccurrence* v1_Symbol) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Symbol)); entity = e; EntityBuffer::Add(this); } +IfcFillAreaStyleTileSymbolWithStyle::IfcFillAreaStyleTileSymbolWithStyle(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFillAreaStyleTileSymbolWithStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFillAreaStyleTileSymbolWithStyle::IfcFillAreaStyleTileSymbolWithStyle(IfcAnnotationSymbolOccurrence* v1_Symbol) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Symbol)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFillAreaStyleTiles -IfcOneDirectionRepeatFactor* IfcFillAreaStyleTiles::TilingPattern() const { return (IfcOneDirectionRepeatFactor*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcFillAreaStyleTiles::setTilingPattern(IfcOneDirectionRepeatFactor* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcEntityList::ptr IfcFillAreaStyleTiles::Tiles() const { return *entity->getArgument(1); } -void IfcFillAreaStyleTiles::setTiles(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcFillAreaStyleTiles::TilingScale() const { return *entity->getArgument(2); } -void IfcFillAreaStyleTiles::setTilingScale(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcFillAreaStyleTiles::is(Type::Enum v) const { return v == Type::IfcFillAreaStyleTiles || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcFillAreaStyleTiles::type() const { return Type::IfcFillAreaStyleTiles; } +IfcOneDirectionRepeatFactor* IfcFillAreaStyleTiles::TilingPattern() const { return (IfcOneDirectionRepeatFactor*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcFillAreaStyleTiles::setTilingPattern(IfcOneDirectionRepeatFactor* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcEntityList::ptr IfcFillAreaStyleTiles::Tiles() const { return *data_->getArgument(1); } +void IfcFillAreaStyleTiles::setTiles(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcFillAreaStyleTiles::TilingScale() const { return *data_->getArgument(2); } +void IfcFillAreaStyleTiles::setTilingScale(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcFillAreaStyleTiles::declaration() const { return *IfcFillAreaStyleTiles_type; } Type::Enum IfcFillAreaStyleTiles::Class() { return Type::IfcFillAreaStyleTiles; } -IfcFillAreaStyleTiles::IfcFillAreaStyleTiles(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFillAreaStyleTiles)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFillAreaStyleTiles::IfcFillAreaStyleTiles(IfcOneDirectionRepeatFactor* v1_TilingPattern, IfcEntityList::ptr v2_Tiles, double v3_TilingScale) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TilingPattern)); e->setArgument(1,(v2_Tiles)); e->setArgument(2,(v3_TilingScale)); entity = e; EntityBuffer::Add(this); } +IfcFillAreaStyleTiles::IfcFillAreaStyleTiles(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFillAreaStyleTiles)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFillAreaStyleTiles::IfcFillAreaStyleTiles(IfcOneDirectionRepeatFactor* v1_TilingPattern, IfcEntityList::ptr v2_Tiles, double v3_TilingScale) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TilingPattern)); e->setArgument(1,(v2_Tiles)); e->setArgument(2,(v3_TilingScale)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFilterType -IfcFilterTypeEnum::IfcFilterTypeEnum IfcFilterType::PredefinedType() const { return IfcFilterTypeEnum::FromString(*entity->getArgument(9)); } -void IfcFilterType::setPredefinedType(IfcFilterTypeEnum::IfcFilterTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcFilterTypeEnum::ToString(v)); } -bool IfcFilterType::is(Type::Enum v) const { return v == Type::IfcFilterType || IfcFlowTreatmentDeviceType::is(v); } -Type::Enum IfcFilterType::type() const { return Type::IfcFilterType; } +IfcFilterTypeEnum::IfcFilterTypeEnum IfcFilterType::PredefinedType() const { return IfcFilterTypeEnum::FromString(*data_->getArgument(9)); } +void IfcFilterType::setPredefinedType(IfcFilterTypeEnum::IfcFilterTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcFilterTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFilterType::declaration() const { return *IfcFilterType_type; } Type::Enum IfcFilterType::Class() { return Type::IfcFilterType; } -IfcFilterType::IfcFilterType(IfcAbstractEntity* e) : IfcFlowTreatmentDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFilterType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFilterType::IfcFilterType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFilterTypeEnum::IfcFilterTypeEnum v10_PredefinedType) : IfcFlowTreatmentDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcFilterTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcFilterType::IfcFilterType(IfcAbstractEntity* e) : IfcFlowTreatmentDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFilterType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFilterType::IfcFilterType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFilterTypeEnum::IfcFilterTypeEnum v10_PredefinedType) : IfcFlowTreatmentDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcFilterTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFireSuppressionTerminalType -IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum IfcFireSuppressionTerminalType::PredefinedType() const { return IfcFireSuppressionTerminalTypeEnum::FromString(*entity->getArgument(9)); } -void IfcFireSuppressionTerminalType::setPredefinedType(IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcFireSuppressionTerminalTypeEnum::ToString(v)); } -bool IfcFireSuppressionTerminalType::is(Type::Enum v) const { return v == Type::IfcFireSuppressionTerminalType || IfcFlowTerminalType::is(v); } -Type::Enum IfcFireSuppressionTerminalType::type() const { return Type::IfcFireSuppressionTerminalType; } +IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum IfcFireSuppressionTerminalType::PredefinedType() const { return IfcFireSuppressionTerminalTypeEnum::FromString(*data_->getArgument(9)); } +void IfcFireSuppressionTerminalType::setPredefinedType(IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcFireSuppressionTerminalTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFireSuppressionTerminalType::declaration() const { return *IfcFireSuppressionTerminalType_type; } Type::Enum IfcFireSuppressionTerminalType::Class() { return Type::IfcFireSuppressionTerminalType; } -IfcFireSuppressionTerminalType::IfcFireSuppressionTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFireSuppressionTerminalType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFireSuppressionTerminalType::IfcFireSuppressionTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcFireSuppressionTerminalTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcFireSuppressionTerminalType::IfcFireSuppressionTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFireSuppressionTerminalType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFireSuppressionTerminalType::IfcFireSuppressionTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcFireSuppressionTerminalTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowController -bool IfcFlowController::is(Type::Enum v) const { return v == Type::IfcFlowController || IfcDistributionFlowElement::is(v); } -Type::Enum IfcFlowController::type() const { return Type::IfcFlowController; } + + +const IfcParse::entity& IfcFlowController::declaration() const { return *IfcFlowController_type; } Type::Enum IfcFlowController::Class() { return Type::IfcFlowController; } -IfcFlowController::IfcFlowController(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowController)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowController::IfcFlowController(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFlowController::IfcFlowController(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowController)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowController::IfcFlowController(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowControllerType -bool IfcFlowControllerType::is(Type::Enum v) const { return v == Type::IfcFlowControllerType || IfcDistributionFlowElementType::is(v); } -Type::Enum IfcFlowControllerType::type() const { return Type::IfcFlowControllerType; } + + +const IfcParse::entity& IfcFlowControllerType::declaration() const { return *IfcFlowControllerType_type; } Type::Enum IfcFlowControllerType::Class() { return Type::IfcFlowControllerType; } -IfcFlowControllerType::IfcFlowControllerType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowControllerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowControllerType::IfcFlowControllerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFlowControllerType::IfcFlowControllerType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowControllerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowControllerType::IfcFlowControllerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowFitting -bool IfcFlowFitting::is(Type::Enum v) const { return v == Type::IfcFlowFitting || IfcDistributionFlowElement::is(v); } -Type::Enum IfcFlowFitting::type() const { return Type::IfcFlowFitting; } + + +const IfcParse::entity& IfcFlowFitting::declaration() const { return *IfcFlowFitting_type; } Type::Enum IfcFlowFitting::Class() { return Type::IfcFlowFitting; } -IfcFlowFitting::IfcFlowFitting(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowFitting)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowFitting::IfcFlowFitting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFlowFitting::IfcFlowFitting(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowFitting)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowFitting::IfcFlowFitting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowFittingType -bool IfcFlowFittingType::is(Type::Enum v) const { return v == Type::IfcFlowFittingType || IfcDistributionFlowElementType::is(v); } -Type::Enum IfcFlowFittingType::type() const { return Type::IfcFlowFittingType; } + + +const IfcParse::entity& IfcFlowFittingType::declaration() const { return *IfcFlowFittingType_type; } Type::Enum IfcFlowFittingType::Class() { return Type::IfcFlowFittingType; } -IfcFlowFittingType::IfcFlowFittingType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowFittingType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowFittingType::IfcFlowFittingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFlowFittingType::IfcFlowFittingType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowFittingType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowFittingType::IfcFlowFittingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowInstrumentType -IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum IfcFlowInstrumentType::PredefinedType() const { return IfcFlowInstrumentTypeEnum::FromString(*entity->getArgument(9)); } -void IfcFlowInstrumentType::setPredefinedType(IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcFlowInstrumentTypeEnum::ToString(v)); } -bool IfcFlowInstrumentType::is(Type::Enum v) const { return v == Type::IfcFlowInstrumentType || IfcDistributionControlElementType::is(v); } -Type::Enum IfcFlowInstrumentType::type() const { return Type::IfcFlowInstrumentType; } +IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum IfcFlowInstrumentType::PredefinedType() const { return IfcFlowInstrumentTypeEnum::FromString(*data_->getArgument(9)); } +void IfcFlowInstrumentType::setPredefinedType(IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcFlowInstrumentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFlowInstrumentType::declaration() const { return *IfcFlowInstrumentType_type; } Type::Enum IfcFlowInstrumentType::Class() { return Type::IfcFlowInstrumentType; } -IfcFlowInstrumentType::IfcFlowInstrumentType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowInstrumentType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowInstrumentType::IfcFlowInstrumentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum v10_PredefinedType) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcFlowInstrumentTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcFlowInstrumentType::IfcFlowInstrumentType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowInstrumentType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowInstrumentType::IfcFlowInstrumentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum v10_PredefinedType) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcFlowInstrumentTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowMeterType -IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum IfcFlowMeterType::PredefinedType() const { return IfcFlowMeterTypeEnum::FromString(*entity->getArgument(9)); } -void IfcFlowMeterType::setPredefinedType(IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcFlowMeterTypeEnum::ToString(v)); } -bool IfcFlowMeterType::is(Type::Enum v) const { return v == Type::IfcFlowMeterType || IfcFlowControllerType::is(v); } -Type::Enum IfcFlowMeterType::type() const { return Type::IfcFlowMeterType; } +IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum IfcFlowMeterType::PredefinedType() const { return IfcFlowMeterTypeEnum::FromString(*data_->getArgument(9)); } +void IfcFlowMeterType::setPredefinedType(IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcFlowMeterTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFlowMeterType::declaration() const { return *IfcFlowMeterType_type; } Type::Enum IfcFlowMeterType::Class() { return Type::IfcFlowMeterType; } -IfcFlowMeterType::IfcFlowMeterType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowMeterType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowMeterType::IfcFlowMeterType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcFlowMeterTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcFlowMeterType::IfcFlowMeterType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowMeterType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowMeterType::IfcFlowMeterType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcFlowMeterTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowMovingDevice -bool IfcFlowMovingDevice::is(Type::Enum v) const { return v == Type::IfcFlowMovingDevice || IfcDistributionFlowElement::is(v); } -Type::Enum IfcFlowMovingDevice::type() const { return Type::IfcFlowMovingDevice; } + + +const IfcParse::entity& IfcFlowMovingDevice::declaration() const { return *IfcFlowMovingDevice_type; } Type::Enum IfcFlowMovingDevice::Class() { return Type::IfcFlowMovingDevice; } -IfcFlowMovingDevice::IfcFlowMovingDevice(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowMovingDevice)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowMovingDevice::IfcFlowMovingDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFlowMovingDevice::IfcFlowMovingDevice(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowMovingDevice)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowMovingDevice::IfcFlowMovingDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowMovingDeviceType -bool IfcFlowMovingDeviceType::is(Type::Enum v) const { return v == Type::IfcFlowMovingDeviceType || IfcDistributionFlowElementType::is(v); } -Type::Enum IfcFlowMovingDeviceType::type() const { return Type::IfcFlowMovingDeviceType; } + + +const IfcParse::entity& IfcFlowMovingDeviceType::declaration() const { return *IfcFlowMovingDeviceType_type; } Type::Enum IfcFlowMovingDeviceType::Class() { return Type::IfcFlowMovingDeviceType; } -IfcFlowMovingDeviceType::IfcFlowMovingDeviceType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowMovingDeviceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowMovingDeviceType::IfcFlowMovingDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFlowMovingDeviceType::IfcFlowMovingDeviceType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowMovingDeviceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowMovingDeviceType::IfcFlowMovingDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowSegment -bool IfcFlowSegment::is(Type::Enum v) const { return v == Type::IfcFlowSegment || IfcDistributionFlowElement::is(v); } -Type::Enum IfcFlowSegment::type() const { return Type::IfcFlowSegment; } + + +const IfcParse::entity& IfcFlowSegment::declaration() const { return *IfcFlowSegment_type; } Type::Enum IfcFlowSegment::Class() { return Type::IfcFlowSegment; } -IfcFlowSegment::IfcFlowSegment(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowSegment)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowSegment::IfcFlowSegment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFlowSegment::IfcFlowSegment(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowSegment)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowSegment::IfcFlowSegment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowSegmentType -bool IfcFlowSegmentType::is(Type::Enum v) const { return v == Type::IfcFlowSegmentType || IfcDistributionFlowElementType::is(v); } -Type::Enum IfcFlowSegmentType::type() const { return Type::IfcFlowSegmentType; } + + +const IfcParse::entity& IfcFlowSegmentType::declaration() const { return *IfcFlowSegmentType_type; } Type::Enum IfcFlowSegmentType::Class() { return Type::IfcFlowSegmentType; } -IfcFlowSegmentType::IfcFlowSegmentType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowSegmentType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowSegmentType::IfcFlowSegmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFlowSegmentType::IfcFlowSegmentType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowSegmentType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowSegmentType::IfcFlowSegmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowStorageDevice -bool IfcFlowStorageDevice::is(Type::Enum v) const { return v == Type::IfcFlowStorageDevice || IfcDistributionFlowElement::is(v); } -Type::Enum IfcFlowStorageDevice::type() const { return Type::IfcFlowStorageDevice; } + + +const IfcParse::entity& IfcFlowStorageDevice::declaration() const { return *IfcFlowStorageDevice_type; } Type::Enum IfcFlowStorageDevice::Class() { return Type::IfcFlowStorageDevice; } -IfcFlowStorageDevice::IfcFlowStorageDevice(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowStorageDevice)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowStorageDevice::IfcFlowStorageDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFlowStorageDevice::IfcFlowStorageDevice(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowStorageDevice)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowStorageDevice::IfcFlowStorageDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowStorageDeviceType -bool IfcFlowStorageDeviceType::is(Type::Enum v) const { return v == Type::IfcFlowStorageDeviceType || IfcDistributionFlowElementType::is(v); } -Type::Enum IfcFlowStorageDeviceType::type() const { return Type::IfcFlowStorageDeviceType; } + + +const IfcParse::entity& IfcFlowStorageDeviceType::declaration() const { return *IfcFlowStorageDeviceType_type; } Type::Enum IfcFlowStorageDeviceType::Class() { return Type::IfcFlowStorageDeviceType; } -IfcFlowStorageDeviceType::IfcFlowStorageDeviceType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowStorageDeviceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowStorageDeviceType::IfcFlowStorageDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFlowStorageDeviceType::IfcFlowStorageDeviceType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowStorageDeviceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowStorageDeviceType::IfcFlowStorageDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowTerminal -bool IfcFlowTerminal::is(Type::Enum v) const { return v == Type::IfcFlowTerminal || IfcDistributionFlowElement::is(v); } -Type::Enum IfcFlowTerminal::type() const { return Type::IfcFlowTerminal; } + + +const IfcParse::entity& IfcFlowTerminal::declaration() const { return *IfcFlowTerminal_type; } Type::Enum IfcFlowTerminal::Class() { return Type::IfcFlowTerminal; } -IfcFlowTerminal::IfcFlowTerminal(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowTerminal)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowTerminal::IfcFlowTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFlowTerminal::IfcFlowTerminal(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowTerminal)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowTerminal::IfcFlowTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowTerminalType -bool IfcFlowTerminalType::is(Type::Enum v) const { return v == Type::IfcFlowTerminalType || IfcDistributionFlowElementType::is(v); } -Type::Enum IfcFlowTerminalType::type() const { return Type::IfcFlowTerminalType; } + + +const IfcParse::entity& IfcFlowTerminalType::declaration() const { return *IfcFlowTerminalType_type; } Type::Enum IfcFlowTerminalType::Class() { return Type::IfcFlowTerminalType; } -IfcFlowTerminalType::IfcFlowTerminalType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowTerminalType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowTerminalType::IfcFlowTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFlowTerminalType::IfcFlowTerminalType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowTerminalType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowTerminalType::IfcFlowTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowTreatmentDevice -bool IfcFlowTreatmentDevice::is(Type::Enum v) const { return v == Type::IfcFlowTreatmentDevice || IfcDistributionFlowElement::is(v); } -Type::Enum IfcFlowTreatmentDevice::type() const { return Type::IfcFlowTreatmentDevice; } + + +const IfcParse::entity& IfcFlowTreatmentDevice::declaration() const { return *IfcFlowTreatmentDevice_type; } Type::Enum IfcFlowTreatmentDevice::Class() { return Type::IfcFlowTreatmentDevice; } -IfcFlowTreatmentDevice::IfcFlowTreatmentDevice(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowTreatmentDevice)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowTreatmentDevice::IfcFlowTreatmentDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFlowTreatmentDevice::IfcFlowTreatmentDevice(IfcAbstractEntity* e) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowTreatmentDevice)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowTreatmentDevice::IfcFlowTreatmentDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFlowTreatmentDeviceType -bool IfcFlowTreatmentDeviceType::is(Type::Enum v) const { return v == Type::IfcFlowTreatmentDeviceType || IfcDistributionFlowElementType::is(v); } -Type::Enum IfcFlowTreatmentDeviceType::type() const { return Type::IfcFlowTreatmentDeviceType; } + + +const IfcParse::entity& IfcFlowTreatmentDeviceType::declaration() const { return *IfcFlowTreatmentDeviceType_type; } Type::Enum IfcFlowTreatmentDeviceType::Class() { return Type::IfcFlowTreatmentDeviceType; } -IfcFlowTreatmentDeviceType::IfcFlowTreatmentDeviceType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowTreatmentDeviceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowTreatmentDeviceType::IfcFlowTreatmentDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFlowTreatmentDeviceType::IfcFlowTreatmentDeviceType(IfcAbstractEntity* e) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowTreatmentDeviceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowTreatmentDeviceType::IfcFlowTreatmentDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFluidFlowProperties -IfcPropertySourceEnum::IfcPropertySourceEnum IfcFluidFlowProperties::PropertySource() const { return IfcPropertySourceEnum::FromString(*entity->getArgument(4)); } -void IfcFluidFlowProperties::setPropertySource(IfcPropertySourceEnum::IfcPropertySourceEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcPropertySourceEnum::ToString(v)); } -bool IfcFluidFlowProperties::hasFlowConditionTimeSeries() const { return !entity->getArgument(5)->isNull(); } -IfcTimeSeries* IfcFluidFlowProperties::FlowConditionTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcFluidFlowProperties::setFlowConditionTimeSeries(IfcTimeSeries* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcFluidFlowProperties::hasVelocityTimeSeries() const { return !entity->getArgument(6)->isNull(); } -IfcTimeSeries* IfcFluidFlowProperties::VelocityTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcFluidFlowProperties::setVelocityTimeSeries(IfcTimeSeries* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcFluidFlowProperties::hasFlowrateTimeSeries() const { return !entity->getArgument(7)->isNull(); } -IfcTimeSeries* IfcFluidFlowProperties::FlowrateTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcFluidFlowProperties::setFlowrateTimeSeries(IfcTimeSeries* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcMaterial* IfcFluidFlowProperties::Fluid() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcFluidFlowProperties::setFluid(IfcMaterial* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcFluidFlowProperties::hasPressureTimeSeries() const { return !entity->getArgument(9)->isNull(); } -IfcTimeSeries* IfcFluidFlowProperties::PressureTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcFluidFlowProperties::setPressureTimeSeries(IfcTimeSeries* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcFluidFlowProperties::hasUserDefinedPropertySource() const { return !entity->getArgument(10)->isNull(); } -std::string IfcFluidFlowProperties::UserDefinedPropertySource() const { return *entity->getArgument(10); } -void IfcFluidFlowProperties::setUserDefinedPropertySource(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcFluidFlowProperties::hasTemperatureSingleValue() const { return !entity->getArgument(11)->isNull(); } -double IfcFluidFlowProperties::TemperatureSingleValue() const { return *entity->getArgument(11); } -void IfcFluidFlowProperties::setTemperatureSingleValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcFluidFlowProperties::hasWetBulbTemperatureSingleValue() const { return !entity->getArgument(12)->isNull(); } -double IfcFluidFlowProperties::WetBulbTemperatureSingleValue() const { return *entity->getArgument(12); } -void IfcFluidFlowProperties::setWetBulbTemperatureSingleValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcFluidFlowProperties::hasWetBulbTemperatureTimeSeries() const { return !entity->getArgument(13)->isNull(); } -IfcTimeSeries* IfcFluidFlowProperties::WetBulbTemperatureTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(13))); } -void IfcFluidFlowProperties::setWetBulbTemperatureTimeSeries(IfcTimeSeries* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcFluidFlowProperties::hasTemperatureTimeSeries() const { return !entity->getArgument(14)->isNull(); } -IfcTimeSeries* IfcFluidFlowProperties::TemperatureTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(14))); } -void IfcFluidFlowProperties::setTemperatureTimeSeries(IfcTimeSeries* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcFluidFlowProperties::hasFlowrateSingleValue() const { return !entity->getArgument(15)->isNull(); } -IfcDerivedMeasureValue* IfcFluidFlowProperties::FlowrateSingleValue() const { return (IfcDerivedMeasureValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(15))); } -void IfcFluidFlowProperties::setFlowrateSingleValue(IfcDerivedMeasureValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v); } -bool IfcFluidFlowProperties::hasFlowConditionSingleValue() const { return !entity->getArgument(16)->isNull(); } -double IfcFluidFlowProperties::FlowConditionSingleValue() const { return *entity->getArgument(16); } -void IfcFluidFlowProperties::setFlowConditionSingleValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(16,v); } -bool IfcFluidFlowProperties::hasVelocitySingleValue() const { return !entity->getArgument(17)->isNull(); } -double IfcFluidFlowProperties::VelocitySingleValue() const { return *entity->getArgument(17); } -void IfcFluidFlowProperties::setVelocitySingleValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(17,v); } -bool IfcFluidFlowProperties::hasPressureSingleValue() const { return !entity->getArgument(18)->isNull(); } -double IfcFluidFlowProperties::PressureSingleValue() const { return *entity->getArgument(18); } -void IfcFluidFlowProperties::setPressureSingleValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(18,v); } -bool IfcFluidFlowProperties::is(Type::Enum v) const { return v == Type::IfcFluidFlowProperties || IfcPropertySetDefinition::is(v); } -Type::Enum IfcFluidFlowProperties::type() const { return Type::IfcFluidFlowProperties; } +IfcPropertySourceEnum::IfcPropertySourceEnum IfcFluidFlowProperties::PropertySource() const { return IfcPropertySourceEnum::FromString(*data_->getArgument(4)); } +void IfcFluidFlowProperties::setPropertySource(IfcPropertySourceEnum::IfcPropertySourceEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcPropertySourceEnum::ToString(v)); } +bool IfcFluidFlowProperties::hasFlowConditionTimeSeries() const { return !data_->getArgument(5)->isNull(); } +IfcTimeSeries* IfcFluidFlowProperties::FlowConditionTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcFluidFlowProperties::setFlowConditionTimeSeries(IfcTimeSeries* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcFluidFlowProperties::hasVelocityTimeSeries() const { return !data_->getArgument(6)->isNull(); } +IfcTimeSeries* IfcFluidFlowProperties::VelocityTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcFluidFlowProperties::setVelocityTimeSeries(IfcTimeSeries* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcFluidFlowProperties::hasFlowrateTimeSeries() const { return !data_->getArgument(7)->isNull(); } +IfcTimeSeries* IfcFluidFlowProperties::FlowrateTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcFluidFlowProperties::setFlowrateTimeSeries(IfcTimeSeries* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +IfcMaterial* IfcFluidFlowProperties::Fluid() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcFluidFlowProperties::setFluid(IfcMaterial* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcFluidFlowProperties::hasPressureTimeSeries() const { return !data_->getArgument(9)->isNull(); } +IfcTimeSeries* IfcFluidFlowProperties::PressureTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcFluidFlowProperties::setPressureTimeSeries(IfcTimeSeries* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcFluidFlowProperties::hasUserDefinedPropertySource() const { return !data_->getArgument(10)->isNull(); } +std::string IfcFluidFlowProperties::UserDefinedPropertySource() const { return *data_->getArgument(10); } +void IfcFluidFlowProperties::setUserDefinedPropertySource(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcFluidFlowProperties::hasTemperatureSingleValue() const { return !data_->getArgument(11)->isNull(); } +double IfcFluidFlowProperties::TemperatureSingleValue() const { return *data_->getArgument(11); } +void IfcFluidFlowProperties::setTemperatureSingleValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcFluidFlowProperties::hasWetBulbTemperatureSingleValue() const { return !data_->getArgument(12)->isNull(); } +double IfcFluidFlowProperties::WetBulbTemperatureSingleValue() const { return *data_->getArgument(12); } +void IfcFluidFlowProperties::setWetBulbTemperatureSingleValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcFluidFlowProperties::hasWetBulbTemperatureTimeSeries() const { return !data_->getArgument(13)->isNull(); } +IfcTimeSeries* IfcFluidFlowProperties::WetBulbTemperatureTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(13))); } +void IfcFluidFlowProperties::setWetBulbTemperatureTimeSeries(IfcTimeSeries* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcFluidFlowProperties::hasTemperatureTimeSeries() const { return !data_->getArgument(14)->isNull(); } +IfcTimeSeries* IfcFluidFlowProperties::TemperatureTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(14))); } +void IfcFluidFlowProperties::setTemperatureTimeSeries(IfcTimeSeries* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } +bool IfcFluidFlowProperties::hasFlowrateSingleValue() const { return !data_->getArgument(15)->isNull(); } +IfcDerivedMeasureValue* IfcFluidFlowProperties::FlowrateSingleValue() const { return (IfcDerivedMeasureValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(15))); } +void IfcFluidFlowProperties::setFlowrateSingleValue(IfcDerivedMeasureValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v); } +bool IfcFluidFlowProperties::hasFlowConditionSingleValue() const { return !data_->getArgument(16)->isNull(); } +double IfcFluidFlowProperties::FlowConditionSingleValue() const { return *data_->getArgument(16); } +void IfcFluidFlowProperties::setFlowConditionSingleValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(16,v); } +bool IfcFluidFlowProperties::hasVelocitySingleValue() const { return !data_->getArgument(17)->isNull(); } +double IfcFluidFlowProperties::VelocitySingleValue() const { return *data_->getArgument(17); } +void IfcFluidFlowProperties::setVelocitySingleValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(17,v); } +bool IfcFluidFlowProperties::hasPressureSingleValue() const { return !data_->getArgument(18)->isNull(); } +double IfcFluidFlowProperties::PressureSingleValue() const { return *data_->getArgument(18); } +void IfcFluidFlowProperties::setPressureSingleValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(18,v); } + + +const IfcParse::entity& IfcFluidFlowProperties::declaration() const { return *IfcFluidFlowProperties_type; } Type::Enum IfcFluidFlowProperties::Class() { return Type::IfcFluidFlowProperties; } -IfcFluidFlowProperties::IfcFluidFlowProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFluidFlowProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFluidFlowProperties::IfcFluidFlowProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPropertySourceEnum::IfcPropertySourceEnum v5_PropertySource, IfcTimeSeries* v6_FlowConditionTimeSeries, IfcTimeSeries* v7_VelocityTimeSeries, IfcTimeSeries* v8_FlowrateTimeSeries, IfcMaterial* v9_Fluid, IfcTimeSeries* v10_PressureTimeSeries, boost::optional< std::string > v11_UserDefinedPropertySource, boost::optional< double > v12_TemperatureSingleValue, boost::optional< double > v13_WetBulbTemperatureSingleValue, IfcTimeSeries* v14_WetBulbTemperatureTimeSeries, IfcTimeSeries* v15_TemperatureTimeSeries, IfcDerivedMeasureValue* v16_FlowrateSingleValue, boost::optional< double > v17_FlowConditionSingleValue, boost::optional< double > v18_VelocitySingleValue, boost::optional< double > v19_PressureSingleValue) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,v5_PropertySource,IfcPropertySourceEnum::ToString(v5_PropertySource)); e->setArgument(5,(v6_FlowConditionTimeSeries)); e->setArgument(6,(v7_VelocityTimeSeries)); e->setArgument(7,(v8_FlowrateTimeSeries)); e->setArgument(8,(v9_Fluid)); e->setArgument(9,(v10_PressureTimeSeries)); if (v11_UserDefinedPropertySource) { e->setArgument(10,(*v11_UserDefinedPropertySource)); } else { e->setArgument(10); } if (v12_TemperatureSingleValue) { e->setArgument(11,(*v12_TemperatureSingleValue)); } else { e->setArgument(11); } if (v13_WetBulbTemperatureSingleValue) { e->setArgument(12,(*v13_WetBulbTemperatureSingleValue)); } else { e->setArgument(12); } e->setArgument(13,(v14_WetBulbTemperatureTimeSeries)); e->setArgument(14,(v15_TemperatureTimeSeries)); e->setArgument(15,(v16_FlowrateSingleValue)); if (v17_FlowConditionSingleValue) { e->setArgument(16,(*v17_FlowConditionSingleValue)); } else { e->setArgument(16); } if (v18_VelocitySingleValue) { e->setArgument(17,(*v18_VelocitySingleValue)); } else { e->setArgument(17); } if (v19_PressureSingleValue) { e->setArgument(18,(*v19_PressureSingleValue)); } else { e->setArgument(18); } entity = e; EntityBuffer::Add(this); } +IfcFluidFlowProperties::IfcFluidFlowProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFluidFlowProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFluidFlowProperties::IfcFluidFlowProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPropertySourceEnum::IfcPropertySourceEnum v5_PropertySource, IfcTimeSeries* v6_FlowConditionTimeSeries, IfcTimeSeries* v7_VelocityTimeSeries, IfcTimeSeries* v8_FlowrateTimeSeries, IfcMaterial* v9_Fluid, IfcTimeSeries* v10_PressureTimeSeries, boost::optional< std::string > v11_UserDefinedPropertySource, boost::optional< double > v12_TemperatureSingleValue, boost::optional< double > v13_WetBulbTemperatureSingleValue, IfcTimeSeries* v14_WetBulbTemperatureTimeSeries, IfcTimeSeries* v15_TemperatureTimeSeries, IfcDerivedMeasureValue* v16_FlowrateSingleValue, boost::optional< double > v17_FlowConditionSingleValue, boost::optional< double > v18_VelocitySingleValue, boost::optional< double > v19_PressureSingleValue) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,v5_PropertySource,IfcPropertySourceEnum::ToString(v5_PropertySource)); e->setArgument(5,(v6_FlowConditionTimeSeries)); e->setArgument(6,(v7_VelocityTimeSeries)); e->setArgument(7,(v8_FlowrateTimeSeries)); e->setArgument(8,(v9_Fluid)); e->setArgument(9,(v10_PressureTimeSeries)); if (v11_UserDefinedPropertySource) { e->setArgument(10,(*v11_UserDefinedPropertySource)); } else { e->setArgument(10); } if (v12_TemperatureSingleValue) { e->setArgument(11,(*v12_TemperatureSingleValue)); } else { e->setArgument(11); } if (v13_WetBulbTemperatureSingleValue) { e->setArgument(12,(*v13_WetBulbTemperatureSingleValue)); } else { e->setArgument(12); } e->setArgument(13,(v14_WetBulbTemperatureTimeSeries)); e->setArgument(14,(v15_TemperatureTimeSeries)); e->setArgument(15,(v16_FlowrateSingleValue)); if (v17_FlowConditionSingleValue) { e->setArgument(16,(*v17_FlowConditionSingleValue)); } else { e->setArgument(16); } if (v18_VelocitySingleValue) { e->setArgument(17,(*v18_VelocitySingleValue)); } else { e->setArgument(17); } if (v19_PressureSingleValue) { e->setArgument(18,(*v19_PressureSingleValue)); } else { e->setArgument(18); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFooting -IfcFootingTypeEnum::IfcFootingTypeEnum IfcFooting::PredefinedType() const { return IfcFootingTypeEnum::FromString(*entity->getArgument(8)); } -void IfcFooting::setPredefinedType(IfcFootingTypeEnum::IfcFootingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcFootingTypeEnum::ToString(v)); } -bool IfcFooting::is(Type::Enum v) const { return v == Type::IfcFooting || IfcBuildingElement::is(v); } -Type::Enum IfcFooting::type() const { return Type::IfcFooting; } +IfcFootingTypeEnum::IfcFootingTypeEnum IfcFooting::PredefinedType() const { return IfcFootingTypeEnum::FromString(*data_->getArgument(8)); } +void IfcFooting::setPredefinedType(IfcFootingTypeEnum::IfcFootingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcFootingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFooting::declaration() const { return *IfcFooting_type; } Type::Enum IfcFooting::Class() { return Type::IfcFooting; } -IfcFooting::IfcFooting(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFooting)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFooting::IfcFooting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcFootingTypeEnum::IfcFootingTypeEnum v9_PredefinedType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_PredefinedType,IfcFootingTypeEnum::ToString(v9_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcFooting::IfcFooting(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFooting)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFooting::IfcFooting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcFootingTypeEnum::IfcFootingTypeEnum v9_PredefinedType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_PredefinedType,IfcFootingTypeEnum::ToString(v9_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFuelProperties -bool IfcFuelProperties::hasCombustionTemperature() const { return !entity->getArgument(1)->isNull(); } -double IfcFuelProperties::CombustionTemperature() const { return *entity->getArgument(1); } -void IfcFuelProperties::setCombustionTemperature(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcFuelProperties::hasCarbonContent() const { return !entity->getArgument(2)->isNull(); } -double IfcFuelProperties::CarbonContent() const { return *entity->getArgument(2); } -void IfcFuelProperties::setCarbonContent(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcFuelProperties::hasLowerHeatingValue() const { return !entity->getArgument(3)->isNull(); } -double IfcFuelProperties::LowerHeatingValue() const { return *entity->getArgument(3); } -void IfcFuelProperties::setLowerHeatingValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcFuelProperties::hasHigherHeatingValue() const { return !entity->getArgument(4)->isNull(); } -double IfcFuelProperties::HigherHeatingValue() const { return *entity->getArgument(4); } -void IfcFuelProperties::setHigherHeatingValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcFuelProperties::is(Type::Enum v) const { return v == Type::IfcFuelProperties || IfcMaterialProperties::is(v); } -Type::Enum IfcFuelProperties::type() const { return Type::IfcFuelProperties; } +bool IfcFuelProperties::hasCombustionTemperature() const { return !data_->getArgument(1)->isNull(); } +double IfcFuelProperties::CombustionTemperature() const { return *data_->getArgument(1); } +void IfcFuelProperties::setCombustionTemperature(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcFuelProperties::hasCarbonContent() const { return !data_->getArgument(2)->isNull(); } +double IfcFuelProperties::CarbonContent() const { return *data_->getArgument(2); } +void IfcFuelProperties::setCarbonContent(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcFuelProperties::hasLowerHeatingValue() const { return !data_->getArgument(3)->isNull(); } +double IfcFuelProperties::LowerHeatingValue() const { return *data_->getArgument(3); } +void IfcFuelProperties::setLowerHeatingValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcFuelProperties::hasHigherHeatingValue() const { return !data_->getArgument(4)->isNull(); } +double IfcFuelProperties::HigherHeatingValue() const { return *data_->getArgument(4); } +void IfcFuelProperties::setHigherHeatingValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcFuelProperties::declaration() const { return *IfcFuelProperties_type; } Type::Enum IfcFuelProperties::Class() { return Type::IfcFuelProperties; } -IfcFuelProperties::IfcFuelProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFuelProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFuelProperties::IfcFuelProperties(IfcMaterial* v1_Material, boost::optional< double > v2_CombustionTemperature, boost::optional< double > v3_CarbonContent, boost::optional< double > v4_LowerHeatingValue, boost::optional< double > v5_HigherHeatingValue) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_CombustionTemperature) { e->setArgument(1,(*v2_CombustionTemperature)); } else { e->setArgument(1); } if (v3_CarbonContent) { e->setArgument(2,(*v3_CarbonContent)); } else { e->setArgument(2); } if (v4_LowerHeatingValue) { e->setArgument(3,(*v4_LowerHeatingValue)); } else { e->setArgument(3); } if (v5_HigherHeatingValue) { e->setArgument(4,(*v5_HigherHeatingValue)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcFuelProperties::IfcFuelProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFuelProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFuelProperties::IfcFuelProperties(IfcMaterial* v1_Material, boost::optional< double > v2_CombustionTemperature, boost::optional< double > v3_CarbonContent, boost::optional< double > v4_LowerHeatingValue, boost::optional< double > v5_HigherHeatingValue) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_CombustionTemperature) { e->setArgument(1,(*v2_CombustionTemperature)); } else { e->setArgument(1); } if (v3_CarbonContent) { e->setArgument(2,(*v3_CarbonContent)); } else { e->setArgument(2); } if (v4_LowerHeatingValue) { e->setArgument(3,(*v4_LowerHeatingValue)); } else { e->setArgument(3); } if (v5_HigherHeatingValue) { e->setArgument(4,(*v5_HigherHeatingValue)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFurnishingElement -bool IfcFurnishingElement::is(Type::Enum v) const { return v == Type::IfcFurnishingElement || IfcElement::is(v); } -Type::Enum IfcFurnishingElement::type() const { return Type::IfcFurnishingElement; } + + +const IfcParse::entity& IfcFurnishingElement::declaration() const { return *IfcFurnishingElement_type; } Type::Enum IfcFurnishingElement::Class() { return Type::IfcFurnishingElement; } -IfcFurnishingElement::IfcFurnishingElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFurnishingElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFurnishingElement::IfcFurnishingElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcFurnishingElement::IfcFurnishingElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFurnishingElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFurnishingElement::IfcFurnishingElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFurnishingElementType -bool IfcFurnishingElementType::is(Type::Enum v) const { return v == Type::IfcFurnishingElementType || IfcElementType::is(v); } -Type::Enum IfcFurnishingElementType::type() const { return Type::IfcFurnishingElementType; } + + +const IfcParse::entity& IfcFurnishingElementType::declaration() const { return *IfcFurnishingElementType_type; } Type::Enum IfcFurnishingElementType::Class() { return Type::IfcFurnishingElementType; } -IfcFurnishingElementType::IfcFurnishingElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFurnishingElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFurnishingElementType::IfcFurnishingElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFurnishingElementType::IfcFurnishingElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFurnishingElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFurnishingElementType::IfcFurnishingElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFurnitureStandard -bool IfcFurnitureStandard::is(Type::Enum v) const { return v == Type::IfcFurnitureStandard || IfcControl::is(v); } -Type::Enum IfcFurnitureStandard::type() const { return Type::IfcFurnitureStandard; } + + +const IfcParse::entity& IfcFurnitureStandard::declaration() const { return *IfcFurnitureStandard_type; } Type::Enum IfcFurnitureStandard::Class() { return Type::IfcFurnitureStandard; } -IfcFurnitureStandard::IfcFurnitureStandard(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFurnitureStandard)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFurnitureStandard::IfcFurnitureStandard(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcFurnitureStandard::IfcFurnitureStandard(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFurnitureStandard)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFurnitureStandard::IfcFurnitureStandard(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFurnitureType -IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum IfcFurnitureType::AssemblyPlace() const { return IfcAssemblyPlaceEnum::FromString(*entity->getArgument(9)); } -void IfcFurnitureType::setAssemblyPlace(IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcAssemblyPlaceEnum::ToString(v)); } -bool IfcFurnitureType::is(Type::Enum v) const { return v == Type::IfcFurnitureType || IfcFurnishingElementType::is(v); } -Type::Enum IfcFurnitureType::type() const { return Type::IfcFurnitureType; } +IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum IfcFurnitureType::AssemblyPlace() const { return IfcAssemblyPlaceEnum::FromString(*data_->getArgument(9)); } +void IfcFurnitureType::setAssemblyPlace(IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcAssemblyPlaceEnum::ToString(v)); } + + +const IfcParse::entity& IfcFurnitureType::declaration() const { return *IfcFurnitureType_type; } Type::Enum IfcFurnitureType::Class() { return Type::IfcFurnitureType; } -IfcFurnitureType::IfcFurnitureType(IfcAbstractEntity* e) : IfcFurnishingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFurnitureType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFurnitureType::IfcFurnitureType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum v10_AssemblyPlace) : IfcFurnishingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_AssemblyPlace,IfcAssemblyPlaceEnum::ToString(v10_AssemblyPlace)); entity = e; EntityBuffer::Add(this); } +IfcFurnitureType::IfcFurnitureType(IfcAbstractEntity* e) : IfcFurnishingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFurnitureType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFurnitureType::IfcFurnitureType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum v10_AssemblyPlace) : IfcFurnishingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_AssemblyPlace,IfcAssemblyPlaceEnum::ToString(v10_AssemblyPlace)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGasTerminalType -IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum IfcGasTerminalType::PredefinedType() const { return IfcGasTerminalTypeEnum::FromString(*entity->getArgument(9)); } -void IfcGasTerminalType::setPredefinedType(IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcGasTerminalTypeEnum::ToString(v)); } -bool IfcGasTerminalType::is(Type::Enum v) const { return v == Type::IfcGasTerminalType || IfcFlowTerminalType::is(v); } -Type::Enum IfcGasTerminalType::type() const { return Type::IfcGasTerminalType; } +IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum IfcGasTerminalType::PredefinedType() const { return IfcGasTerminalTypeEnum::FromString(*data_->getArgument(9)); } +void IfcGasTerminalType::setPredefinedType(IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcGasTerminalTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcGasTerminalType::declaration() const { return *IfcGasTerminalType_type; } Type::Enum IfcGasTerminalType::Class() { return Type::IfcGasTerminalType; } -IfcGasTerminalType::IfcGasTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGasTerminalType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGasTerminalType::IfcGasTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcGasTerminalTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcGasTerminalType::IfcGasTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGasTerminalType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGasTerminalType::IfcGasTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcGasTerminalTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGeneralMaterialProperties -bool IfcGeneralMaterialProperties::hasMolecularWeight() const { return !entity->getArgument(1)->isNull(); } -double IfcGeneralMaterialProperties::MolecularWeight() const { return *entity->getArgument(1); } -void IfcGeneralMaterialProperties::setMolecularWeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcGeneralMaterialProperties::hasPorosity() const { return !entity->getArgument(2)->isNull(); } -double IfcGeneralMaterialProperties::Porosity() const { return *entity->getArgument(2); } -void IfcGeneralMaterialProperties::setPorosity(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcGeneralMaterialProperties::hasMassDensity() const { return !entity->getArgument(3)->isNull(); } -double IfcGeneralMaterialProperties::MassDensity() const { return *entity->getArgument(3); } -void IfcGeneralMaterialProperties::setMassDensity(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcGeneralMaterialProperties::is(Type::Enum v) const { return v == Type::IfcGeneralMaterialProperties || IfcMaterialProperties::is(v); } -Type::Enum IfcGeneralMaterialProperties::type() const { return Type::IfcGeneralMaterialProperties; } +bool IfcGeneralMaterialProperties::hasMolecularWeight() const { return !data_->getArgument(1)->isNull(); } +double IfcGeneralMaterialProperties::MolecularWeight() const { return *data_->getArgument(1); } +void IfcGeneralMaterialProperties::setMolecularWeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcGeneralMaterialProperties::hasPorosity() const { return !data_->getArgument(2)->isNull(); } +double IfcGeneralMaterialProperties::Porosity() const { return *data_->getArgument(2); } +void IfcGeneralMaterialProperties::setPorosity(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcGeneralMaterialProperties::hasMassDensity() const { return !data_->getArgument(3)->isNull(); } +double IfcGeneralMaterialProperties::MassDensity() const { return *data_->getArgument(3); } +void IfcGeneralMaterialProperties::setMassDensity(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcGeneralMaterialProperties::declaration() const { return *IfcGeneralMaterialProperties_type; } Type::Enum IfcGeneralMaterialProperties::Class() { return Type::IfcGeneralMaterialProperties; } -IfcGeneralMaterialProperties::IfcGeneralMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeneralMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGeneralMaterialProperties::IfcGeneralMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_MolecularWeight, boost::optional< double > v3_Porosity, boost::optional< double > v4_MassDensity) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_MolecularWeight) { e->setArgument(1,(*v2_MolecularWeight)); } else { e->setArgument(1); } if (v3_Porosity) { e->setArgument(2,(*v3_Porosity)); } else { e->setArgument(2); } if (v4_MassDensity) { e->setArgument(3,(*v4_MassDensity)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcGeneralMaterialProperties::IfcGeneralMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeneralMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGeneralMaterialProperties::IfcGeneralMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_MolecularWeight, boost::optional< double > v3_Porosity, boost::optional< double > v4_MassDensity) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_MolecularWeight) { e->setArgument(1,(*v2_MolecularWeight)); } else { e->setArgument(1); } if (v3_Porosity) { e->setArgument(2,(*v3_Porosity)); } else { e->setArgument(2); } if (v4_MassDensity) { e->setArgument(3,(*v4_MassDensity)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGeneralProfileProperties -bool IfcGeneralProfileProperties::hasPhysicalWeight() const { return !entity->getArgument(2)->isNull(); } -double IfcGeneralProfileProperties::PhysicalWeight() const { return *entity->getArgument(2); } -void IfcGeneralProfileProperties::setPhysicalWeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcGeneralProfileProperties::hasPerimeter() const { return !entity->getArgument(3)->isNull(); } -double IfcGeneralProfileProperties::Perimeter() const { return *entity->getArgument(3); } -void IfcGeneralProfileProperties::setPerimeter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcGeneralProfileProperties::hasMinimumPlateThickness() const { return !entity->getArgument(4)->isNull(); } -double IfcGeneralProfileProperties::MinimumPlateThickness() const { return *entity->getArgument(4); } -void IfcGeneralProfileProperties::setMinimumPlateThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcGeneralProfileProperties::hasMaximumPlateThickness() const { return !entity->getArgument(5)->isNull(); } -double IfcGeneralProfileProperties::MaximumPlateThickness() const { return *entity->getArgument(5); } -void IfcGeneralProfileProperties::setMaximumPlateThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcGeneralProfileProperties::hasCrossSectionArea() const { return !entity->getArgument(6)->isNull(); } -double IfcGeneralProfileProperties::CrossSectionArea() const { return *entity->getArgument(6); } -void IfcGeneralProfileProperties::setCrossSectionArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcGeneralProfileProperties::is(Type::Enum v) const { return v == Type::IfcGeneralProfileProperties || IfcProfileProperties::is(v); } -Type::Enum IfcGeneralProfileProperties::type() const { return Type::IfcGeneralProfileProperties; } +bool IfcGeneralProfileProperties::hasPhysicalWeight() const { return !data_->getArgument(2)->isNull(); } +double IfcGeneralProfileProperties::PhysicalWeight() const { return *data_->getArgument(2); } +void IfcGeneralProfileProperties::setPhysicalWeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcGeneralProfileProperties::hasPerimeter() const { return !data_->getArgument(3)->isNull(); } +double IfcGeneralProfileProperties::Perimeter() const { return *data_->getArgument(3); } +void IfcGeneralProfileProperties::setPerimeter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcGeneralProfileProperties::hasMinimumPlateThickness() const { return !data_->getArgument(4)->isNull(); } +double IfcGeneralProfileProperties::MinimumPlateThickness() const { return *data_->getArgument(4); } +void IfcGeneralProfileProperties::setMinimumPlateThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcGeneralProfileProperties::hasMaximumPlateThickness() const { return !data_->getArgument(5)->isNull(); } +double IfcGeneralProfileProperties::MaximumPlateThickness() const { return *data_->getArgument(5); } +void IfcGeneralProfileProperties::setMaximumPlateThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcGeneralProfileProperties::hasCrossSectionArea() const { return !data_->getArgument(6)->isNull(); } +double IfcGeneralProfileProperties::CrossSectionArea() const { return *data_->getArgument(6); } +void IfcGeneralProfileProperties::setCrossSectionArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcGeneralProfileProperties::declaration() const { return *IfcGeneralProfileProperties_type; } Type::Enum IfcGeneralProfileProperties::Class() { return Type::IfcGeneralProfileProperties; } -IfcGeneralProfileProperties::IfcGeneralProfileProperties(IfcAbstractEntity* e) : IfcProfileProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeneralProfileProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGeneralProfileProperties::IfcGeneralProfileProperties(boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea) : IfcProfileProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ProfileName) { e->setArgument(0,(*v1_ProfileName)); } else { e->setArgument(0); } e->setArgument(1,(v2_ProfileDefinition)); if (v3_PhysicalWeight) { e->setArgument(2,(*v3_PhysicalWeight)); } else { e->setArgument(2); } if (v4_Perimeter) { e->setArgument(3,(*v4_Perimeter)); } else { e->setArgument(3); } if (v5_MinimumPlateThickness) { e->setArgument(4,(*v5_MinimumPlateThickness)); } else { e->setArgument(4); } if (v6_MaximumPlateThickness) { e->setArgument(5,(*v6_MaximumPlateThickness)); } else { e->setArgument(5); } if (v7_CrossSectionArea) { e->setArgument(6,(*v7_CrossSectionArea)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcGeneralProfileProperties::IfcGeneralProfileProperties(IfcAbstractEntity* e) : IfcProfileProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeneralProfileProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGeneralProfileProperties::IfcGeneralProfileProperties(boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea) : IfcProfileProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ProfileName) { e->setArgument(0,(*v1_ProfileName)); } else { e->setArgument(0); } e->setArgument(1,(v2_ProfileDefinition)); if (v3_PhysicalWeight) { e->setArgument(2,(*v3_PhysicalWeight)); } else { e->setArgument(2); } if (v4_Perimeter) { e->setArgument(3,(*v4_Perimeter)); } else { e->setArgument(3); } if (v5_MinimumPlateThickness) { e->setArgument(4,(*v5_MinimumPlateThickness)); } else { e->setArgument(4); } if (v6_MaximumPlateThickness) { e->setArgument(5,(*v6_MaximumPlateThickness)); } else { e->setArgument(5); } if (v7_CrossSectionArea) { e->setArgument(6,(*v7_CrossSectionArea)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGeometricCurveSet -bool IfcGeometricCurveSet::is(Type::Enum v) const { return v == Type::IfcGeometricCurveSet || IfcGeometricSet::is(v); } -Type::Enum IfcGeometricCurveSet::type() const { return Type::IfcGeometricCurveSet; } + + +const IfcParse::entity& IfcGeometricCurveSet::declaration() const { return *IfcGeometricCurveSet_type; } Type::Enum IfcGeometricCurveSet::Class() { return Type::IfcGeometricCurveSet; } -IfcGeometricCurveSet::IfcGeometricCurveSet(IfcAbstractEntity* e) : IfcGeometricSet((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeometricCurveSet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGeometricCurveSet::IfcGeometricCurveSet(IfcEntityList::ptr v1_Elements) : IfcGeometricSet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Elements)); entity = e; EntityBuffer::Add(this); } +IfcGeometricCurveSet::IfcGeometricCurveSet(IfcAbstractEntity* e) : IfcGeometricSet((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeometricCurveSet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGeometricCurveSet::IfcGeometricCurveSet(IfcEntityList::ptr v1_Elements) : IfcGeometricSet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Elements)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGeometricRepresentationContext -int IfcGeometricRepresentationContext::CoordinateSpaceDimension() const { return *entity->getArgument(2); } -void IfcGeometricRepresentationContext::setCoordinateSpaceDimension(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcGeometricRepresentationContext::hasPrecision() const { return !entity->getArgument(3)->isNull(); } -double IfcGeometricRepresentationContext::Precision() const { return *entity->getArgument(3); } -void IfcGeometricRepresentationContext::setPrecision(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -IfcAxis2Placement* IfcGeometricRepresentationContext::WorldCoordinateSystem() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcGeometricRepresentationContext::setWorldCoordinateSystem(IfcAxis2Placement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcGeometricRepresentationContext::hasTrueNorth() const { return !entity->getArgument(5)->isNull(); } -IfcDirection* IfcGeometricRepresentationContext::TrueNorth() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcGeometricRepresentationContext::setTrueNorth(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcGeometricRepresentationSubContext::list::ptr IfcGeometricRepresentationContext::HasSubContexts() const { return entity->getInverse(Type::IfcGeometricRepresentationSubContext, 6)->as(); } -bool IfcGeometricRepresentationContext::is(Type::Enum v) const { return v == Type::IfcGeometricRepresentationContext || IfcRepresentationContext::is(v); } -Type::Enum IfcGeometricRepresentationContext::type() const { return Type::IfcGeometricRepresentationContext; } +int IfcGeometricRepresentationContext::CoordinateSpaceDimension() const { return *data_->getArgument(2); } +void IfcGeometricRepresentationContext::setCoordinateSpaceDimension(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcGeometricRepresentationContext::hasPrecision() const { return !data_->getArgument(3)->isNull(); } +double IfcGeometricRepresentationContext::Precision() const { return *data_->getArgument(3); } +void IfcGeometricRepresentationContext::setPrecision(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +IfcAxis2Placement* IfcGeometricRepresentationContext::WorldCoordinateSystem() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcGeometricRepresentationContext::setWorldCoordinateSystem(IfcAxis2Placement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcGeometricRepresentationContext::hasTrueNorth() const { return !data_->getArgument(5)->isNull(); } +IfcDirection* IfcGeometricRepresentationContext::TrueNorth() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcGeometricRepresentationContext::setTrueNorth(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + +IfcGeometricRepresentationSubContext::list::ptr IfcGeometricRepresentationContext::HasSubContexts() const { return data_->getInverse(Type::IfcGeometricRepresentationSubContext, 6)->as(); } + +const IfcParse::entity& IfcGeometricRepresentationContext::declaration() const { return *IfcGeometricRepresentationContext_type; } Type::Enum IfcGeometricRepresentationContext::Class() { return Type::IfcGeometricRepresentationContext; } -IfcGeometricRepresentationContext::IfcGeometricRepresentationContext(IfcAbstractEntity* e) : IfcRepresentationContext((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeometricRepresentationContext)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGeometricRepresentationContext::IfcGeometricRepresentationContext(boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType, int v3_CoordinateSpaceDimension, boost::optional< double > v4_Precision, IfcAxis2Placement* v5_WorldCoordinateSystem, IfcDirection* v6_TrueNorth) : IfcRepresentationContext((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ContextIdentifier) { e->setArgument(0,(*v1_ContextIdentifier)); } else { e->setArgument(0); } if (v2_ContextType) { e->setArgument(1,(*v2_ContextType)); } else { e->setArgument(1); } e->setArgument(2,(v3_CoordinateSpaceDimension)); if (v4_Precision) { e->setArgument(3,(*v4_Precision)); } else { e->setArgument(3); } e->setArgument(4,(v5_WorldCoordinateSystem)); e->setArgument(5,(v6_TrueNorth)); entity = e; EntityBuffer::Add(this); } +IfcGeometricRepresentationContext::IfcGeometricRepresentationContext(IfcAbstractEntity* e) : IfcRepresentationContext((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeometricRepresentationContext)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGeometricRepresentationContext::IfcGeometricRepresentationContext(boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType, int v3_CoordinateSpaceDimension, boost::optional< double > v4_Precision, IfcAxis2Placement* v5_WorldCoordinateSystem, IfcDirection* v6_TrueNorth) : IfcRepresentationContext((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ContextIdentifier) { e->setArgument(0,(*v1_ContextIdentifier)); } else { e->setArgument(0); } if (v2_ContextType) { e->setArgument(1,(*v2_ContextType)); } else { e->setArgument(1); } e->setArgument(2,(v3_CoordinateSpaceDimension)); if (v4_Precision) { e->setArgument(3,(*v4_Precision)); } else { e->setArgument(3); } e->setArgument(4,(v5_WorldCoordinateSystem)); e->setArgument(5,(v6_TrueNorth)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGeometricRepresentationItem -bool IfcGeometricRepresentationItem::is(Type::Enum v) const { return v == Type::IfcGeometricRepresentationItem || IfcRepresentationItem::is(v); } -Type::Enum IfcGeometricRepresentationItem::type() const { return Type::IfcGeometricRepresentationItem; } + + +const IfcParse::entity& IfcGeometricRepresentationItem::declaration() const { return *IfcGeometricRepresentationItem_type; } Type::Enum IfcGeometricRepresentationItem::Class() { return Type::IfcGeometricRepresentationItem; } -IfcGeometricRepresentationItem::IfcGeometricRepresentationItem(IfcAbstractEntity* e) : IfcRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeometricRepresentationItem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGeometricRepresentationItem::IfcGeometricRepresentationItem() : IfcRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcGeometricRepresentationItem::IfcGeometricRepresentationItem(IfcAbstractEntity* e) : IfcRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeometricRepresentationItem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGeometricRepresentationItem::IfcGeometricRepresentationItem() : IfcRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGeometricRepresentationSubContext -IfcGeometricRepresentationContext* IfcGeometricRepresentationSubContext::ParentContext() const { return (IfcGeometricRepresentationContext*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcGeometricRepresentationSubContext::setParentContext(IfcGeometricRepresentationContext* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcGeometricRepresentationSubContext::hasTargetScale() const { return !entity->getArgument(7)->isNull(); } -double IfcGeometricRepresentationSubContext::TargetScale() const { return *entity->getArgument(7); } -void IfcGeometricRepresentationSubContext::setTargetScale(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcGeometricProjectionEnum::IfcGeometricProjectionEnum IfcGeometricRepresentationSubContext::TargetView() const { return IfcGeometricProjectionEnum::FromString(*entity->getArgument(8)); } -void IfcGeometricRepresentationSubContext::setTargetView(IfcGeometricProjectionEnum::IfcGeometricProjectionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcGeometricProjectionEnum::ToString(v)); } -bool IfcGeometricRepresentationSubContext::hasUserDefinedTargetView() const { return !entity->getArgument(9)->isNull(); } -std::string IfcGeometricRepresentationSubContext::UserDefinedTargetView() const { return *entity->getArgument(9); } -void IfcGeometricRepresentationSubContext::setUserDefinedTargetView(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcGeometricRepresentationSubContext::is(Type::Enum v) const { return v == Type::IfcGeometricRepresentationSubContext || IfcGeometricRepresentationContext::is(v); } -Type::Enum IfcGeometricRepresentationSubContext::type() const { return Type::IfcGeometricRepresentationSubContext; } +IfcGeometricRepresentationContext* IfcGeometricRepresentationSubContext::ParentContext() const { return (IfcGeometricRepresentationContext*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcGeometricRepresentationSubContext::setParentContext(IfcGeometricRepresentationContext* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcGeometricRepresentationSubContext::hasTargetScale() const { return !data_->getArgument(7)->isNull(); } +double IfcGeometricRepresentationSubContext::TargetScale() const { return *data_->getArgument(7); } +void IfcGeometricRepresentationSubContext::setTargetScale(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +IfcGeometricProjectionEnum::IfcGeometricProjectionEnum IfcGeometricRepresentationSubContext::TargetView() const { return IfcGeometricProjectionEnum::FromString(*data_->getArgument(8)); } +void IfcGeometricRepresentationSubContext::setTargetView(IfcGeometricProjectionEnum::IfcGeometricProjectionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcGeometricProjectionEnum::ToString(v)); } +bool IfcGeometricRepresentationSubContext::hasUserDefinedTargetView() const { return !data_->getArgument(9)->isNull(); } +std::string IfcGeometricRepresentationSubContext::UserDefinedTargetView() const { return *data_->getArgument(9); } +void IfcGeometricRepresentationSubContext::setUserDefinedTargetView(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcGeometricRepresentationSubContext::declaration() const { return *IfcGeometricRepresentationSubContext_type; } Type::Enum IfcGeometricRepresentationSubContext::Class() { return Type::IfcGeometricRepresentationSubContext; } -IfcGeometricRepresentationSubContext::IfcGeometricRepresentationSubContext(IfcAbstractEntity* e) : IfcGeometricRepresentationContext((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeometricRepresentationSubContext)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGeometricRepresentationSubContext::IfcGeometricRepresentationSubContext(boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType, IfcGeometricRepresentationContext* v7_ParentContext, boost::optional< double > v8_TargetScale, IfcGeometricProjectionEnum::IfcGeometricProjectionEnum v9_TargetView, boost::optional< std::string > v10_UserDefinedTargetView) : IfcGeometricRepresentationContext((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ContextIdentifier) { e->setArgument(0,(*v1_ContextIdentifier)); } else { e->setArgument(0); } if (v2_ContextType) { e->setArgument(1,(*v2_ContextType)); } else { e->setArgument(1); } e->setArgumentDerived(2); e->setArgumentDerived(3); e->setArgumentDerived(4); e->setArgumentDerived(5); e->setArgument(6,(v7_ParentContext)); if (v8_TargetScale) { e->setArgument(7,(*v8_TargetScale)); } else { e->setArgument(7); } e->setArgument(8,v9_TargetView,IfcGeometricProjectionEnum::ToString(v9_TargetView)); if (v10_UserDefinedTargetView) { e->setArgument(9,(*v10_UserDefinedTargetView)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcGeometricRepresentationSubContext::IfcGeometricRepresentationSubContext(IfcAbstractEntity* e) : IfcGeometricRepresentationContext((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeometricRepresentationSubContext)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGeometricRepresentationSubContext::IfcGeometricRepresentationSubContext(boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType, IfcGeometricRepresentationContext* v7_ParentContext, boost::optional< double > v8_TargetScale, IfcGeometricProjectionEnum::IfcGeometricProjectionEnum v9_TargetView, boost::optional< std::string > v10_UserDefinedTargetView) : IfcGeometricRepresentationContext((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ContextIdentifier) { e->setArgument(0,(*v1_ContextIdentifier)); } else { e->setArgument(0); } if (v2_ContextType) { e->setArgument(1,(*v2_ContextType)); } else { e->setArgument(1); } e->setArgumentDerived(2); e->setArgumentDerived(3); e->setArgumentDerived(4); e->setArgumentDerived(5); e->setArgument(6,(v7_ParentContext)); if (v8_TargetScale) { e->setArgument(7,(*v8_TargetScale)); } else { e->setArgument(7); } e->setArgument(8,v9_TargetView,IfcGeometricProjectionEnum::ToString(v9_TargetView)); if (v10_UserDefinedTargetView) { e->setArgument(9,(*v10_UserDefinedTargetView)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGeometricSet -IfcEntityList::ptr IfcGeometricSet::Elements() const { return *entity->getArgument(0); } -void IfcGeometricSet::setElements(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcGeometricSet::is(Type::Enum v) const { return v == Type::IfcGeometricSet || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcGeometricSet::type() const { return Type::IfcGeometricSet; } +IfcEntityList::ptr IfcGeometricSet::Elements() const { return *data_->getArgument(0); } +void IfcGeometricSet::setElements(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcGeometricSet::declaration() const { return *IfcGeometricSet_type; } Type::Enum IfcGeometricSet::Class() { return Type::IfcGeometricSet; } -IfcGeometricSet::IfcGeometricSet(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeometricSet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGeometricSet::IfcGeometricSet(IfcEntityList::ptr v1_Elements) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Elements)); entity = e; EntityBuffer::Add(this); } +IfcGeometricSet::IfcGeometricSet(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeometricSet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGeometricSet::IfcGeometricSet(IfcEntityList::ptr v1_Elements) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Elements)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGrid -IfcTemplatedEntityList< IfcGridAxis >::ptr IfcGrid::UAxes() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcGrid::setUAxes(IfcTemplatedEntityList< IfcGridAxis >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -IfcTemplatedEntityList< IfcGridAxis >::ptr IfcGrid::VAxes() const { IfcEntityList::ptr es = *entity->getArgument(8); return es->as(); } -void IfcGrid::setVAxes(IfcTemplatedEntityList< IfcGridAxis >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v->generalize()); } -bool IfcGrid::hasWAxes() const { return !entity->getArgument(9)->isNull(); } -IfcTemplatedEntityList< IfcGridAxis >::ptr IfcGrid::WAxes() const { IfcEntityList::ptr es = *entity->getArgument(9); return es->as(); } -void IfcGrid::setWAxes(IfcTemplatedEntityList< IfcGridAxis >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v->generalize()); } -IfcRelContainedInSpatialStructure::list::ptr IfcGrid::ContainedInStructure() const { return entity->getInverse(Type::IfcRelContainedInSpatialStructure, 4)->as(); } -bool IfcGrid::is(Type::Enum v) const { return v == Type::IfcGrid || IfcProduct::is(v); } -Type::Enum IfcGrid::type() const { return Type::IfcGrid; } +IfcTemplatedEntityList< IfcGridAxis >::ptr IfcGrid::UAxes() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcGrid::setUAxes(IfcTemplatedEntityList< IfcGridAxis >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } +IfcTemplatedEntityList< IfcGridAxis >::ptr IfcGrid::VAxes() const { IfcEntityList::ptr es = *data_->getArgument(8); return es->as(); } +void IfcGrid::setVAxes(IfcTemplatedEntityList< IfcGridAxis >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v->generalize()); } +bool IfcGrid::hasWAxes() const { return !data_->getArgument(9)->isNull(); } +IfcTemplatedEntityList< IfcGridAxis >::ptr IfcGrid::WAxes() const { IfcEntityList::ptr es = *data_->getArgument(9); return es->as(); } +void IfcGrid::setWAxes(IfcTemplatedEntityList< IfcGridAxis >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v->generalize()); } + +IfcRelContainedInSpatialStructure::list::ptr IfcGrid::ContainedInStructure() const { return data_->getInverse(Type::IfcRelContainedInSpatialStructure, 4)->as(); } + +const IfcParse::entity& IfcGrid::declaration() const { return *IfcGrid_type; } Type::Enum IfcGrid::Class() { return Type::IfcGrid; } -IfcGrid::IfcGrid(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGrid)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGrid::IfcGrid(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcTemplatedEntityList< IfcGridAxis >::ptr v8_UAxes, IfcTemplatedEntityList< IfcGridAxis >::ptr v9_VAxes, boost::optional< IfcTemplatedEntityList< IfcGridAxis >::ptr > v10_WAxes) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_UAxes)->generalize()); e->setArgument(8,(v9_VAxes)->generalize()); if (v10_WAxes) { e->setArgument(9,(*v10_WAxes)->generalize()); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcGrid::IfcGrid(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGrid)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGrid::IfcGrid(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcTemplatedEntityList< IfcGridAxis >::ptr v8_UAxes, IfcTemplatedEntityList< IfcGridAxis >::ptr v9_VAxes, boost::optional< IfcTemplatedEntityList< IfcGridAxis >::ptr > v10_WAxes) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_UAxes)->generalize()); e->setArgument(8,(v9_VAxes)->generalize()); if (v10_WAxes) { e->setArgument(9,(*v10_WAxes)->generalize()); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGridAxis -bool IfcGridAxis::hasAxisTag() const { return !entity->getArgument(0)->isNull(); } -std::string IfcGridAxis::AxisTag() const { return *entity->getArgument(0); } -void IfcGridAxis::setAxisTag(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcCurve* IfcGridAxis::AxisCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcGridAxis::setAxisCurve(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcGridAxis::SameSense() const { return *entity->getArgument(2); } -void IfcGridAxis::setSameSense(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcGrid::list::ptr IfcGridAxis::PartOfW() const { return entity->getInverse(Type::IfcGrid, 9)->as(); } -IfcGrid::list::ptr IfcGridAxis::PartOfV() const { return entity->getInverse(Type::IfcGrid, 8)->as(); } -IfcGrid::list::ptr IfcGridAxis::PartOfU() const { return entity->getInverse(Type::IfcGrid, 7)->as(); } -IfcVirtualGridIntersection::list::ptr IfcGridAxis::HasIntersections() const { return entity->getInverse(Type::IfcVirtualGridIntersection, 0)->as(); } -bool IfcGridAxis::is(Type::Enum v) const { return v == Type::IfcGridAxis; } -Type::Enum IfcGridAxis::type() const { return Type::IfcGridAxis; } +bool IfcGridAxis::hasAxisTag() const { return !data_->getArgument(0)->isNull(); } +std::string IfcGridAxis::AxisTag() const { return *data_->getArgument(0); } +void IfcGridAxis::setAxisTag(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcCurve* IfcGridAxis::AxisCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcGridAxis::setAxisCurve(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcGridAxis::SameSense() const { return *data_->getArgument(2); } +void IfcGridAxis::setSameSense(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + +IfcGrid::list::ptr IfcGridAxis::PartOfW() const { return data_->getInverse(Type::IfcGrid, 9)->as(); } +IfcGrid::list::ptr IfcGridAxis::PartOfV() const { return data_->getInverse(Type::IfcGrid, 8)->as(); } +IfcGrid::list::ptr IfcGridAxis::PartOfU() const { return data_->getInverse(Type::IfcGrid, 7)->as(); } +IfcVirtualGridIntersection::list::ptr IfcGridAxis::HasIntersections() const { return data_->getInverse(Type::IfcVirtualGridIntersection, 0)->as(); } + +const IfcParse::entity& IfcGridAxis::declaration() const { return *IfcGridAxis_type; } Type::Enum IfcGridAxis::Class() { return Type::IfcGridAxis; } -IfcGridAxis::IfcGridAxis(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcGridAxis)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGridAxis::IfcGridAxis(boost::optional< std::string > v1_AxisTag, IfcCurve* v2_AxisCurve, bool v3_SameSense) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_AxisTag) { e->setArgument(0,(*v1_AxisTag)); } else { e->setArgument(0); } e->setArgument(1,(v2_AxisCurve)); e->setArgument(2,(v3_SameSense)); entity = e; EntityBuffer::Add(this); } +IfcGridAxis::IfcGridAxis(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcGridAxis)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGridAxis::IfcGridAxis(boost::optional< std::string > v1_AxisTag, IfcCurve* v2_AxisCurve, bool v3_SameSense) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_AxisTag) { e->setArgument(0,(*v1_AxisTag)); } else { e->setArgument(0); } e->setArgument(1,(v2_AxisCurve)); e->setArgument(2,(v3_SameSense)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGridPlacement -IfcVirtualGridIntersection* IfcGridPlacement::PlacementLocation() const { return (IfcVirtualGridIntersection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcGridPlacement::setPlacementLocation(IfcVirtualGridIntersection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcGridPlacement::hasPlacementRefDirection() const { return !entity->getArgument(1)->isNull(); } -IfcVirtualGridIntersection* IfcGridPlacement::PlacementRefDirection() const { return (IfcVirtualGridIntersection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcGridPlacement::setPlacementRefDirection(IfcVirtualGridIntersection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcGridPlacement::is(Type::Enum v) const { return v == Type::IfcGridPlacement || IfcObjectPlacement::is(v); } -Type::Enum IfcGridPlacement::type() const { return Type::IfcGridPlacement; } +IfcVirtualGridIntersection* IfcGridPlacement::PlacementLocation() const { return (IfcVirtualGridIntersection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcGridPlacement::setPlacementLocation(IfcVirtualGridIntersection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcGridPlacement::hasPlacementRefDirection() const { return !data_->getArgument(1)->isNull(); } +IfcVirtualGridIntersection* IfcGridPlacement::PlacementRefDirection() const { return (IfcVirtualGridIntersection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcGridPlacement::setPlacementRefDirection(IfcVirtualGridIntersection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcGridPlacement::declaration() const { return *IfcGridPlacement_type; } Type::Enum IfcGridPlacement::Class() { return Type::IfcGridPlacement; } -IfcGridPlacement::IfcGridPlacement(IfcAbstractEntity* e) : IfcObjectPlacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGridPlacement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGridPlacement::IfcGridPlacement(IfcVirtualGridIntersection* v1_PlacementLocation, IfcVirtualGridIntersection* v2_PlacementRefDirection) : IfcObjectPlacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_PlacementLocation)); e->setArgument(1,(v2_PlacementRefDirection)); entity = e; EntityBuffer::Add(this); } +IfcGridPlacement::IfcGridPlacement(IfcAbstractEntity* e) : IfcObjectPlacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGridPlacement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGridPlacement::IfcGridPlacement(IfcVirtualGridIntersection* v1_PlacementLocation, IfcVirtualGridIntersection* v2_PlacementRefDirection) : IfcObjectPlacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_PlacementLocation)); e->setArgument(1,(v2_PlacementRefDirection)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGroup -IfcRelAssignsToGroup::list::ptr IfcGroup::IsGroupedBy() const { return entity->getInverse(Type::IfcRelAssignsToGroup, 6)->as(); } -bool IfcGroup::is(Type::Enum v) const { return v == Type::IfcGroup || IfcObject::is(v); } -Type::Enum IfcGroup::type() const { return Type::IfcGroup; } + +IfcRelAssignsToGroup::list::ptr IfcGroup::IsGroupedBy() const { return data_->getInverse(Type::IfcRelAssignsToGroup, 6)->as(); } + +const IfcParse::entity& IfcGroup::declaration() const { return *IfcGroup_type; } Type::Enum IfcGroup::Class() { return Type::IfcGroup; } -IfcGroup::IfcGroup(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGroup)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGroup::IfcGroup(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcGroup::IfcGroup(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGroup)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGroup::IfcGroup(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcHalfSpaceSolid -IfcSurface* IfcHalfSpaceSolid::BaseSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcHalfSpaceSolid::setBaseSurface(IfcSurface* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcHalfSpaceSolid::AgreementFlag() const { return *entity->getArgument(1); } -void IfcHalfSpaceSolid::setAgreementFlag(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcHalfSpaceSolid::is(Type::Enum v) const { return v == Type::IfcHalfSpaceSolid || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcHalfSpaceSolid::type() const { return Type::IfcHalfSpaceSolid; } +IfcSurface* IfcHalfSpaceSolid::BaseSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcHalfSpaceSolid::setBaseSurface(IfcSurface* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcHalfSpaceSolid::AgreementFlag() const { return *data_->getArgument(1); } +void IfcHalfSpaceSolid::setAgreementFlag(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcHalfSpaceSolid::declaration() const { return *IfcHalfSpaceSolid_type; } Type::Enum IfcHalfSpaceSolid::Class() { return Type::IfcHalfSpaceSolid; } -IfcHalfSpaceSolid::IfcHalfSpaceSolid(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHalfSpaceSolid)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcHalfSpaceSolid::IfcHalfSpaceSolid(IfcSurface* v1_BaseSurface, bool v2_AgreementFlag) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BaseSurface)); e->setArgument(1,(v2_AgreementFlag)); entity = e; EntityBuffer::Add(this); } +IfcHalfSpaceSolid::IfcHalfSpaceSolid(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHalfSpaceSolid)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcHalfSpaceSolid::IfcHalfSpaceSolid(IfcSurface* v1_BaseSurface, bool v2_AgreementFlag) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BaseSurface)); e->setArgument(1,(v2_AgreementFlag)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcHeatExchangerType -IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum IfcHeatExchangerType::PredefinedType() const { return IfcHeatExchangerTypeEnum::FromString(*entity->getArgument(9)); } -void IfcHeatExchangerType::setPredefinedType(IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcHeatExchangerTypeEnum::ToString(v)); } -bool IfcHeatExchangerType::is(Type::Enum v) const { return v == Type::IfcHeatExchangerType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcHeatExchangerType::type() const { return Type::IfcHeatExchangerType; } +IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum IfcHeatExchangerType::PredefinedType() const { return IfcHeatExchangerTypeEnum::FromString(*data_->getArgument(9)); } +void IfcHeatExchangerType::setPredefinedType(IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcHeatExchangerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcHeatExchangerType::declaration() const { return *IfcHeatExchangerType_type; } Type::Enum IfcHeatExchangerType::Class() { return Type::IfcHeatExchangerType; } -IfcHeatExchangerType::IfcHeatExchangerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHeatExchangerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcHeatExchangerType::IfcHeatExchangerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcHeatExchangerTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcHeatExchangerType::IfcHeatExchangerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHeatExchangerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcHeatExchangerType::IfcHeatExchangerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcHeatExchangerTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcHumidifierType -IfcHumidifierTypeEnum::IfcHumidifierTypeEnum IfcHumidifierType::PredefinedType() const { return IfcHumidifierTypeEnum::FromString(*entity->getArgument(9)); } -void IfcHumidifierType::setPredefinedType(IfcHumidifierTypeEnum::IfcHumidifierTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcHumidifierTypeEnum::ToString(v)); } -bool IfcHumidifierType::is(Type::Enum v) const { return v == Type::IfcHumidifierType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcHumidifierType::type() const { return Type::IfcHumidifierType; } +IfcHumidifierTypeEnum::IfcHumidifierTypeEnum IfcHumidifierType::PredefinedType() const { return IfcHumidifierTypeEnum::FromString(*data_->getArgument(9)); } +void IfcHumidifierType::setPredefinedType(IfcHumidifierTypeEnum::IfcHumidifierTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcHumidifierTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcHumidifierType::declaration() const { return *IfcHumidifierType_type; } Type::Enum IfcHumidifierType::Class() { return Type::IfcHumidifierType; } -IfcHumidifierType::IfcHumidifierType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHumidifierType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcHumidifierType::IfcHumidifierType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcHumidifierTypeEnum::IfcHumidifierTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcHumidifierTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcHumidifierType::IfcHumidifierType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHumidifierType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcHumidifierType::IfcHumidifierType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcHumidifierTypeEnum::IfcHumidifierTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcHumidifierTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcHygroscopicMaterialProperties -bool IfcHygroscopicMaterialProperties::hasUpperVaporResistanceFactor() const { return !entity->getArgument(1)->isNull(); } -double IfcHygroscopicMaterialProperties::UpperVaporResistanceFactor() const { return *entity->getArgument(1); } -void IfcHygroscopicMaterialProperties::setUpperVaporResistanceFactor(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcHygroscopicMaterialProperties::hasLowerVaporResistanceFactor() const { return !entity->getArgument(2)->isNull(); } -double IfcHygroscopicMaterialProperties::LowerVaporResistanceFactor() const { return *entity->getArgument(2); } -void IfcHygroscopicMaterialProperties::setLowerVaporResistanceFactor(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcHygroscopicMaterialProperties::hasIsothermalMoistureCapacity() const { return !entity->getArgument(3)->isNull(); } -double IfcHygroscopicMaterialProperties::IsothermalMoistureCapacity() const { return *entity->getArgument(3); } -void IfcHygroscopicMaterialProperties::setIsothermalMoistureCapacity(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcHygroscopicMaterialProperties::hasVaporPermeability() const { return !entity->getArgument(4)->isNull(); } -double IfcHygroscopicMaterialProperties::VaporPermeability() const { return *entity->getArgument(4); } -void IfcHygroscopicMaterialProperties::setVaporPermeability(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcHygroscopicMaterialProperties::hasMoistureDiffusivity() const { return !entity->getArgument(5)->isNull(); } -double IfcHygroscopicMaterialProperties::MoistureDiffusivity() const { return *entity->getArgument(5); } -void IfcHygroscopicMaterialProperties::setMoistureDiffusivity(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcHygroscopicMaterialProperties::is(Type::Enum v) const { return v == Type::IfcHygroscopicMaterialProperties || IfcMaterialProperties::is(v); } -Type::Enum IfcHygroscopicMaterialProperties::type() const { return Type::IfcHygroscopicMaterialProperties; } +bool IfcHygroscopicMaterialProperties::hasUpperVaporResistanceFactor() const { return !data_->getArgument(1)->isNull(); } +double IfcHygroscopicMaterialProperties::UpperVaporResistanceFactor() const { return *data_->getArgument(1); } +void IfcHygroscopicMaterialProperties::setUpperVaporResistanceFactor(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcHygroscopicMaterialProperties::hasLowerVaporResistanceFactor() const { return !data_->getArgument(2)->isNull(); } +double IfcHygroscopicMaterialProperties::LowerVaporResistanceFactor() const { return *data_->getArgument(2); } +void IfcHygroscopicMaterialProperties::setLowerVaporResistanceFactor(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcHygroscopicMaterialProperties::hasIsothermalMoistureCapacity() const { return !data_->getArgument(3)->isNull(); } +double IfcHygroscopicMaterialProperties::IsothermalMoistureCapacity() const { return *data_->getArgument(3); } +void IfcHygroscopicMaterialProperties::setIsothermalMoistureCapacity(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcHygroscopicMaterialProperties::hasVaporPermeability() const { return !data_->getArgument(4)->isNull(); } +double IfcHygroscopicMaterialProperties::VaporPermeability() const { return *data_->getArgument(4); } +void IfcHygroscopicMaterialProperties::setVaporPermeability(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcHygroscopicMaterialProperties::hasMoistureDiffusivity() const { return !data_->getArgument(5)->isNull(); } +double IfcHygroscopicMaterialProperties::MoistureDiffusivity() const { return *data_->getArgument(5); } +void IfcHygroscopicMaterialProperties::setMoistureDiffusivity(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcHygroscopicMaterialProperties::declaration() const { return *IfcHygroscopicMaterialProperties_type; } Type::Enum IfcHygroscopicMaterialProperties::Class() { return Type::IfcHygroscopicMaterialProperties; } -IfcHygroscopicMaterialProperties::IfcHygroscopicMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHygroscopicMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcHygroscopicMaterialProperties::IfcHygroscopicMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_UpperVaporResistanceFactor, boost::optional< double > v3_LowerVaporResistanceFactor, boost::optional< double > v4_IsothermalMoistureCapacity, boost::optional< double > v5_VaporPermeability, boost::optional< double > v6_MoistureDiffusivity) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_UpperVaporResistanceFactor) { e->setArgument(1,(*v2_UpperVaporResistanceFactor)); } else { e->setArgument(1); } if (v3_LowerVaporResistanceFactor) { e->setArgument(2,(*v3_LowerVaporResistanceFactor)); } else { e->setArgument(2); } if (v4_IsothermalMoistureCapacity) { e->setArgument(3,(*v4_IsothermalMoistureCapacity)); } else { e->setArgument(3); } if (v5_VaporPermeability) { e->setArgument(4,(*v5_VaporPermeability)); } else { e->setArgument(4); } if (v6_MoistureDiffusivity) { e->setArgument(5,(*v6_MoistureDiffusivity)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcHygroscopicMaterialProperties::IfcHygroscopicMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHygroscopicMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcHygroscopicMaterialProperties::IfcHygroscopicMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_UpperVaporResistanceFactor, boost::optional< double > v3_LowerVaporResistanceFactor, boost::optional< double > v4_IsothermalMoistureCapacity, boost::optional< double > v5_VaporPermeability, boost::optional< double > v6_MoistureDiffusivity) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_UpperVaporResistanceFactor) { e->setArgument(1,(*v2_UpperVaporResistanceFactor)); } else { e->setArgument(1); } if (v3_LowerVaporResistanceFactor) { e->setArgument(2,(*v3_LowerVaporResistanceFactor)); } else { e->setArgument(2); } if (v4_IsothermalMoistureCapacity) { e->setArgument(3,(*v4_IsothermalMoistureCapacity)); } else { e->setArgument(3); } if (v5_VaporPermeability) { e->setArgument(4,(*v5_VaporPermeability)); } else { e->setArgument(4); } if (v6_MoistureDiffusivity) { e->setArgument(5,(*v6_MoistureDiffusivity)); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcIShapeProfileDef -double IfcIShapeProfileDef::OverallWidth() const { return *entity->getArgument(3); } -void IfcIShapeProfileDef::setOverallWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcIShapeProfileDef::OverallDepth() const { return *entity->getArgument(4); } -void IfcIShapeProfileDef::setOverallDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -double IfcIShapeProfileDef::WebThickness() const { return *entity->getArgument(5); } -void IfcIShapeProfileDef::setWebThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcIShapeProfileDef::FlangeThickness() const { return *entity->getArgument(6); } -void IfcIShapeProfileDef::setFlangeThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcIShapeProfileDef::hasFilletRadius() const { return !entity->getArgument(7)->isNull(); } -double IfcIShapeProfileDef::FilletRadius() const { return *entity->getArgument(7); } -void IfcIShapeProfileDef::setFilletRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcIShapeProfileDef::is(Type::Enum v) const { return v == Type::IfcIShapeProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcIShapeProfileDef::type() const { return Type::IfcIShapeProfileDef; } +double IfcIShapeProfileDef::OverallWidth() const { return *data_->getArgument(3); } +void IfcIShapeProfileDef::setOverallWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcIShapeProfileDef::OverallDepth() const { return *data_->getArgument(4); } +void IfcIShapeProfileDef::setOverallDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +double IfcIShapeProfileDef::WebThickness() const { return *data_->getArgument(5); } +void IfcIShapeProfileDef::setWebThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcIShapeProfileDef::FlangeThickness() const { return *data_->getArgument(6); } +void IfcIShapeProfileDef::setFlangeThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcIShapeProfileDef::hasFilletRadius() const { return !data_->getArgument(7)->isNull(); } +double IfcIShapeProfileDef::FilletRadius() const { return *data_->getArgument(7); } +void IfcIShapeProfileDef::setFilletRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcIShapeProfileDef::declaration() const { return *IfcIShapeProfileDef_type; } Type::Enum IfcIShapeProfileDef::Class() { return Type::IfcIShapeProfileDef; } -IfcIShapeProfileDef::IfcIShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcIShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcIShapeProfileDef::IfcIShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallWidth, double v5_OverallDepth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_OverallWidth)); e->setArgument(4,(v5_OverallDepth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_FlangeThickness)); if (v8_FilletRadius) { e->setArgument(7,(*v8_FilletRadius)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcIShapeProfileDef::IfcIShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcIShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcIShapeProfileDef::IfcIShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallWidth, double v5_OverallDepth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_OverallWidth)); e->setArgument(4,(v5_OverallDepth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_FlangeThickness)); if (v8_FilletRadius) { e->setArgument(7,(*v8_FilletRadius)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcImageTexture -std::string IfcImageTexture::UrlReference() const { return *entity->getArgument(4); } -void IfcImageTexture::setUrlReference(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcImageTexture::is(Type::Enum v) const { return v == Type::IfcImageTexture || IfcSurfaceTexture::is(v); } -Type::Enum IfcImageTexture::type() const { return Type::IfcImageTexture; } +std::string IfcImageTexture::UrlReference() const { return *data_->getArgument(4); } +void IfcImageTexture::setUrlReference(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcImageTexture::declaration() const { return *IfcImageTexture_type; } Type::Enum IfcImageTexture::Class() { return Type::IfcImageTexture; } -IfcImageTexture::IfcImageTexture(IfcAbstractEntity* e) : IfcSurfaceTexture((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcImageTexture)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcImageTexture::IfcImageTexture(bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform, std::string v5_UrlReference) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); e->setArgument(2,v3_TextureType,IfcSurfaceTextureEnum::ToString(v3_TextureType)); e->setArgument(3,(v4_TextureTransform)); e->setArgument(4,(v5_UrlReference)); entity = e; EntityBuffer::Add(this); } +IfcImageTexture::IfcImageTexture(IfcAbstractEntity* e) : IfcSurfaceTexture((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcImageTexture)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcImageTexture::IfcImageTexture(bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform, std::string v5_UrlReference) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); e->setArgument(2,v3_TextureType,IfcSurfaceTextureEnum::ToString(v3_TextureType)); e->setArgument(3,(v4_TextureTransform)); e->setArgument(4,(v5_UrlReference)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcInventory -IfcInventoryTypeEnum::IfcInventoryTypeEnum IfcInventory::InventoryType() const { return IfcInventoryTypeEnum::FromString(*entity->getArgument(5)); } -void IfcInventory::setInventoryType(IfcInventoryTypeEnum::IfcInventoryTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcInventoryTypeEnum::ToString(v)); } -IfcActorSelect* IfcInventory::Jurisdiction() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcInventory::setJurisdiction(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcTemplatedEntityList< IfcPerson >::ptr IfcInventory::ResponsiblePersons() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcInventory::setResponsiblePersons(IfcTemplatedEntityList< IfcPerson >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -IfcCalendarDate* IfcInventory::LastUpdateDate() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcInventory::setLastUpdateDate(IfcCalendarDate* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcInventory::hasCurrentValue() const { return !entity->getArgument(9)->isNull(); } -IfcCostValue* IfcInventory::CurrentValue() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcInventory::setCurrentValue(IfcCostValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcInventory::hasOriginalValue() const { return !entity->getArgument(10)->isNull(); } -IfcCostValue* IfcInventory::OriginalValue() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcInventory::setOriginalValue(IfcCostValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcInventory::is(Type::Enum v) const { return v == Type::IfcInventory || IfcGroup::is(v); } -Type::Enum IfcInventory::type() const { return Type::IfcInventory; } +IfcInventoryTypeEnum::IfcInventoryTypeEnum IfcInventory::InventoryType() const { return IfcInventoryTypeEnum::FromString(*data_->getArgument(5)); } +void IfcInventory::setInventoryType(IfcInventoryTypeEnum::IfcInventoryTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcInventoryTypeEnum::ToString(v)); } +IfcActorSelect* IfcInventory::Jurisdiction() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcInventory::setJurisdiction(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +IfcTemplatedEntityList< IfcPerson >::ptr IfcInventory::ResponsiblePersons() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcInventory::setResponsiblePersons(IfcTemplatedEntityList< IfcPerson >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } +IfcCalendarDate* IfcInventory::LastUpdateDate() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcInventory::setLastUpdateDate(IfcCalendarDate* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcInventory::hasCurrentValue() const { return !data_->getArgument(9)->isNull(); } +IfcCostValue* IfcInventory::CurrentValue() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcInventory::setCurrentValue(IfcCostValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcInventory::hasOriginalValue() const { return !data_->getArgument(10)->isNull(); } +IfcCostValue* IfcInventory::OriginalValue() const { return (IfcCostValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcInventory::setOriginalValue(IfcCostValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcInventory::declaration() const { return *IfcInventory_type; } Type::Enum IfcInventory::Class() { return Type::IfcInventory; } -IfcInventory::IfcInventory(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcInventory)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcInventory::IfcInventory(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcInventoryTypeEnum::IfcInventoryTypeEnum v6_InventoryType, IfcActorSelect* v7_Jurisdiction, IfcTemplatedEntityList< IfcPerson >::ptr v8_ResponsiblePersons, IfcCalendarDate* v9_LastUpdateDate, IfcCostValue* v10_CurrentValue, IfcCostValue* v11_OriginalValue) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,v6_InventoryType,IfcInventoryTypeEnum::ToString(v6_InventoryType)); e->setArgument(6,(v7_Jurisdiction)); e->setArgument(7,(v8_ResponsiblePersons)->generalize()); e->setArgument(8,(v9_LastUpdateDate)); e->setArgument(9,(v10_CurrentValue)); e->setArgument(10,(v11_OriginalValue)); entity = e; EntityBuffer::Add(this); } +IfcInventory::IfcInventory(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcInventory)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcInventory::IfcInventory(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcInventoryTypeEnum::IfcInventoryTypeEnum v6_InventoryType, IfcActorSelect* v7_Jurisdiction, IfcTemplatedEntityList< IfcPerson >::ptr v8_ResponsiblePersons, IfcCalendarDate* v9_LastUpdateDate, IfcCostValue* v10_CurrentValue, IfcCostValue* v11_OriginalValue) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,v6_InventoryType,IfcInventoryTypeEnum::ToString(v6_InventoryType)); e->setArgument(6,(v7_Jurisdiction)); e->setArgument(7,(v8_ResponsiblePersons)->generalize()); e->setArgument(8,(v9_LastUpdateDate)); e->setArgument(9,(v10_CurrentValue)); e->setArgument(10,(v11_OriginalValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcIrregularTimeSeries -IfcTemplatedEntityList< IfcIrregularTimeSeriesValue >::ptr IfcIrregularTimeSeries::Values() const { IfcEntityList::ptr es = *entity->getArgument(8); return es->as(); } -void IfcIrregularTimeSeries::setValues(IfcTemplatedEntityList< IfcIrregularTimeSeriesValue >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v->generalize()); } -bool IfcIrregularTimeSeries::is(Type::Enum v) const { return v == Type::IfcIrregularTimeSeries || IfcTimeSeries::is(v); } -Type::Enum IfcIrregularTimeSeries::type() const { return Type::IfcIrregularTimeSeries; } +IfcTemplatedEntityList< IfcIrregularTimeSeriesValue >::ptr IfcIrregularTimeSeries::Values() const { IfcEntityList::ptr es = *data_->getArgument(8); return es->as(); } +void IfcIrregularTimeSeries::setValues(IfcTemplatedEntityList< IfcIrregularTimeSeriesValue >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v->generalize()); } + + +const IfcParse::entity& IfcIrregularTimeSeries::declaration() const { return *IfcIrregularTimeSeries_type; } Type::Enum IfcIrregularTimeSeries::Class() { return Type::IfcIrregularTimeSeries; } -IfcIrregularTimeSeries::IfcIrregularTimeSeries(IfcAbstractEntity* e) : IfcTimeSeries((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcIrregularTimeSeries)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcIrregularTimeSeries::IfcIrregularTimeSeries(std::string v1_Name, boost::optional< std::string > v2_Description, IfcDateTimeSelect* v3_StartTime, IfcDateTimeSelect* v4_EndTime, IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v5_TimeSeriesDataType, IfcDataOriginEnum::IfcDataOriginEnum v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, IfcUnit* v8_Unit, IfcTemplatedEntityList< IfcIrregularTimeSeriesValue >::ptr v9_Values) : IfcTimeSeries((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_StartTime)); e->setArgument(3,(v4_EndTime)); e->setArgument(4,v5_TimeSeriesDataType,IfcTimeSeriesDataTypeEnum::ToString(v5_TimeSeriesDataType)); e->setArgument(5,v6_DataOrigin,IfcDataOriginEnum::ToString(v6_DataOrigin)); if (v7_UserDefinedDataOrigin) { e->setArgument(6,(*v7_UserDefinedDataOrigin)); } else { e->setArgument(6); } e->setArgument(7,(v8_Unit)); e->setArgument(8,(v9_Values)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcIrregularTimeSeries::IfcIrregularTimeSeries(IfcAbstractEntity* e) : IfcTimeSeries((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcIrregularTimeSeries)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcIrregularTimeSeries::IfcIrregularTimeSeries(std::string v1_Name, boost::optional< std::string > v2_Description, IfcDateTimeSelect* v3_StartTime, IfcDateTimeSelect* v4_EndTime, IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v5_TimeSeriesDataType, IfcDataOriginEnum::IfcDataOriginEnum v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, IfcUnit* v8_Unit, IfcTemplatedEntityList< IfcIrregularTimeSeriesValue >::ptr v9_Values) : IfcTimeSeries((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_StartTime)); e->setArgument(3,(v4_EndTime)); e->setArgument(4,v5_TimeSeriesDataType,IfcTimeSeriesDataTypeEnum::ToString(v5_TimeSeriesDataType)); e->setArgument(5,v6_DataOrigin,IfcDataOriginEnum::ToString(v6_DataOrigin)); if (v7_UserDefinedDataOrigin) { e->setArgument(6,(*v7_UserDefinedDataOrigin)); } else { e->setArgument(6); } e->setArgument(7,(v8_Unit)); e->setArgument(8,(v9_Values)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcIrregularTimeSeriesValue -IfcDateTimeSelect* IfcIrregularTimeSeriesValue::TimeStamp() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcIrregularTimeSeriesValue::setTimeStamp(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcEntityList::ptr IfcIrregularTimeSeriesValue::ListValues() const { return *entity->getArgument(1); } -void IfcIrregularTimeSeriesValue::setListValues(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcIrregularTimeSeriesValue::is(Type::Enum v) const { return v == Type::IfcIrregularTimeSeriesValue; } -Type::Enum IfcIrregularTimeSeriesValue::type() const { return Type::IfcIrregularTimeSeriesValue; } +IfcDateTimeSelect* IfcIrregularTimeSeriesValue::TimeStamp() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcIrregularTimeSeriesValue::setTimeStamp(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcEntityList::ptr IfcIrregularTimeSeriesValue::ListValues() const { return *data_->getArgument(1); } +void IfcIrregularTimeSeriesValue::setListValues(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcIrregularTimeSeriesValue::declaration() const { return *IfcIrregularTimeSeriesValue_type; } Type::Enum IfcIrregularTimeSeriesValue::Class() { return Type::IfcIrregularTimeSeriesValue; } -IfcIrregularTimeSeriesValue::IfcIrregularTimeSeriesValue(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcIrregularTimeSeriesValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcIrregularTimeSeriesValue::IfcIrregularTimeSeriesValue(IfcDateTimeSelect* v1_TimeStamp, IfcEntityList::ptr v2_ListValues) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TimeStamp)); e->setArgument(1,(v2_ListValues)); entity = e; EntityBuffer::Add(this); } +IfcIrregularTimeSeriesValue::IfcIrregularTimeSeriesValue(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcIrregularTimeSeriesValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcIrregularTimeSeriesValue::IfcIrregularTimeSeriesValue(IfcDateTimeSelect* v1_TimeStamp, IfcEntityList::ptr v2_ListValues) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TimeStamp)); e->setArgument(1,(v2_ListValues)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcJunctionBoxType -IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum IfcJunctionBoxType::PredefinedType() const { return IfcJunctionBoxTypeEnum::FromString(*entity->getArgument(9)); } -void IfcJunctionBoxType::setPredefinedType(IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcJunctionBoxTypeEnum::ToString(v)); } -bool IfcJunctionBoxType::is(Type::Enum v) const { return v == Type::IfcJunctionBoxType || IfcFlowFittingType::is(v); } -Type::Enum IfcJunctionBoxType::type() const { return Type::IfcJunctionBoxType; } +IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum IfcJunctionBoxType::PredefinedType() const { return IfcJunctionBoxTypeEnum::FromString(*data_->getArgument(9)); } +void IfcJunctionBoxType::setPredefinedType(IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcJunctionBoxTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcJunctionBoxType::declaration() const { return *IfcJunctionBoxType_type; } Type::Enum IfcJunctionBoxType::Class() { return Type::IfcJunctionBoxType; } -IfcJunctionBoxType::IfcJunctionBoxType(IfcAbstractEntity* e) : IfcFlowFittingType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcJunctionBoxType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcJunctionBoxType::IfcJunctionBoxType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum v10_PredefinedType) : IfcFlowFittingType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcJunctionBoxTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcJunctionBoxType::IfcJunctionBoxType(IfcAbstractEntity* e) : IfcFlowFittingType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcJunctionBoxType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcJunctionBoxType::IfcJunctionBoxType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum v10_PredefinedType) : IfcFlowFittingType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcJunctionBoxTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLShapeProfileDef -double IfcLShapeProfileDef::Depth() const { return *entity->getArgument(3); } -void IfcLShapeProfileDef::setDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcLShapeProfileDef::hasWidth() const { return !entity->getArgument(4)->isNull(); } -double IfcLShapeProfileDef::Width() const { return *entity->getArgument(4); } -void IfcLShapeProfileDef::setWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -double IfcLShapeProfileDef::Thickness() const { return *entity->getArgument(5); } -void IfcLShapeProfileDef::setThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcLShapeProfileDef::hasFilletRadius() const { return !entity->getArgument(6)->isNull(); } -double IfcLShapeProfileDef::FilletRadius() const { return *entity->getArgument(6); } -void IfcLShapeProfileDef::setFilletRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcLShapeProfileDef::hasEdgeRadius() const { return !entity->getArgument(7)->isNull(); } -double IfcLShapeProfileDef::EdgeRadius() const { return *entity->getArgument(7); } -void IfcLShapeProfileDef::setEdgeRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcLShapeProfileDef::hasLegSlope() const { return !entity->getArgument(8)->isNull(); } -double IfcLShapeProfileDef::LegSlope() const { return *entity->getArgument(8); } -void IfcLShapeProfileDef::setLegSlope(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcLShapeProfileDef::hasCentreOfGravityInX() const { return !entity->getArgument(9)->isNull(); } -double IfcLShapeProfileDef::CentreOfGravityInX() const { return *entity->getArgument(9); } -void IfcLShapeProfileDef::setCentreOfGravityInX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcLShapeProfileDef::hasCentreOfGravityInY() const { return !entity->getArgument(10)->isNull(); } -double IfcLShapeProfileDef::CentreOfGravityInY() const { return *entity->getArgument(10); } -void IfcLShapeProfileDef::setCentreOfGravityInY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcLShapeProfileDef::is(Type::Enum v) const { return v == Type::IfcLShapeProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcLShapeProfileDef::type() const { return Type::IfcLShapeProfileDef; } +double IfcLShapeProfileDef::Depth() const { return *data_->getArgument(3); } +void IfcLShapeProfileDef::setDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcLShapeProfileDef::hasWidth() const { return !data_->getArgument(4)->isNull(); } +double IfcLShapeProfileDef::Width() const { return *data_->getArgument(4); } +void IfcLShapeProfileDef::setWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +double IfcLShapeProfileDef::Thickness() const { return *data_->getArgument(5); } +void IfcLShapeProfileDef::setThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcLShapeProfileDef::hasFilletRadius() const { return !data_->getArgument(6)->isNull(); } +double IfcLShapeProfileDef::FilletRadius() const { return *data_->getArgument(6); } +void IfcLShapeProfileDef::setFilletRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcLShapeProfileDef::hasEdgeRadius() const { return !data_->getArgument(7)->isNull(); } +double IfcLShapeProfileDef::EdgeRadius() const { return *data_->getArgument(7); } +void IfcLShapeProfileDef::setEdgeRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcLShapeProfileDef::hasLegSlope() const { return !data_->getArgument(8)->isNull(); } +double IfcLShapeProfileDef::LegSlope() const { return *data_->getArgument(8); } +void IfcLShapeProfileDef::setLegSlope(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcLShapeProfileDef::hasCentreOfGravityInX() const { return !data_->getArgument(9)->isNull(); } +double IfcLShapeProfileDef::CentreOfGravityInX() const { return *data_->getArgument(9); } +void IfcLShapeProfileDef::setCentreOfGravityInX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcLShapeProfileDef::hasCentreOfGravityInY() const { return !data_->getArgument(10)->isNull(); } +double IfcLShapeProfileDef::CentreOfGravityInY() const { return *data_->getArgument(10); } +void IfcLShapeProfileDef::setCentreOfGravityInY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcLShapeProfileDef::declaration() const { return *IfcLShapeProfileDef_type; } Type::Enum IfcLShapeProfileDef::Class() { return Type::IfcLShapeProfileDef; } -IfcLShapeProfileDef::IfcLShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLShapeProfileDef::IfcLShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, boost::optional< double > v5_Width, double v6_Thickness, boost::optional< double > v7_FilletRadius, boost::optional< double > v8_EdgeRadius, boost::optional< double > v9_LegSlope, boost::optional< double > v10_CentreOfGravityInX, boost::optional< double > v11_CentreOfGravityInY) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Depth)); if (v5_Width) { e->setArgument(4,(*v5_Width)); } else { e->setArgument(4); } e->setArgument(5,(v6_Thickness)); if (v7_FilletRadius) { e->setArgument(6,(*v7_FilletRadius)); } else { e->setArgument(6); } if (v8_EdgeRadius) { e->setArgument(7,(*v8_EdgeRadius)); } else { e->setArgument(7); } if (v9_LegSlope) { e->setArgument(8,(*v9_LegSlope)); } else { e->setArgument(8); } if (v10_CentreOfGravityInX) { e->setArgument(9,(*v10_CentreOfGravityInX)); } else { e->setArgument(9); } if (v11_CentreOfGravityInY) { e->setArgument(10,(*v11_CentreOfGravityInY)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcLShapeProfileDef::IfcLShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLShapeProfileDef::IfcLShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, boost::optional< double > v5_Width, double v6_Thickness, boost::optional< double > v7_FilletRadius, boost::optional< double > v8_EdgeRadius, boost::optional< double > v9_LegSlope, boost::optional< double > v10_CentreOfGravityInX, boost::optional< double > v11_CentreOfGravityInY) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Depth)); if (v5_Width) { e->setArgument(4,(*v5_Width)); } else { e->setArgument(4); } e->setArgument(5,(v6_Thickness)); if (v7_FilletRadius) { e->setArgument(6,(*v7_FilletRadius)); } else { e->setArgument(6); } if (v8_EdgeRadius) { e->setArgument(7,(*v8_EdgeRadius)); } else { e->setArgument(7); } if (v9_LegSlope) { e->setArgument(8,(*v9_LegSlope)); } else { e->setArgument(8); } if (v10_CentreOfGravityInX) { e->setArgument(9,(*v10_CentreOfGravityInX)); } else { e->setArgument(9); } if (v11_CentreOfGravityInY) { e->setArgument(10,(*v11_CentreOfGravityInY)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLaborResource -bool IfcLaborResource::hasSkillSet() const { return !entity->getArgument(9)->isNull(); } -std::string IfcLaborResource::SkillSet() const { return *entity->getArgument(9); } -void IfcLaborResource::setSkillSet(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcLaborResource::is(Type::Enum v) const { return v == Type::IfcLaborResource || IfcConstructionResource::is(v); } -Type::Enum IfcLaborResource::type() const { return Type::IfcLaborResource; } +bool IfcLaborResource::hasSkillSet() const { return !data_->getArgument(9)->isNull(); } +std::string IfcLaborResource::SkillSet() const { return *data_->getArgument(9); } +void IfcLaborResource::setSkillSet(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcLaborResource::declaration() const { return *IfcLaborResource_type; } Type::Enum IfcLaborResource::Class() { return Type::IfcLaborResource; } -IfcLaborResource::IfcLaborResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLaborResource)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLaborResource::IfcLaborResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity, boost::optional< std::string > v10_SkillSet) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); if (v10_SkillSet) { e->setArgument(9,(*v10_SkillSet)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcLaborResource::IfcLaborResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLaborResource)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLaborResource::IfcLaborResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity, boost::optional< std::string > v10_SkillSet) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); if (v10_SkillSet) { e->setArgument(9,(*v10_SkillSet)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLampType -IfcLampTypeEnum::IfcLampTypeEnum IfcLampType::PredefinedType() const { return IfcLampTypeEnum::FromString(*entity->getArgument(9)); } -void IfcLampType::setPredefinedType(IfcLampTypeEnum::IfcLampTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcLampTypeEnum::ToString(v)); } -bool IfcLampType::is(Type::Enum v) const { return v == Type::IfcLampType || IfcFlowTerminalType::is(v); } -Type::Enum IfcLampType::type() const { return Type::IfcLampType; } +IfcLampTypeEnum::IfcLampTypeEnum IfcLampType::PredefinedType() const { return IfcLampTypeEnum::FromString(*data_->getArgument(9)); } +void IfcLampType::setPredefinedType(IfcLampTypeEnum::IfcLampTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcLampTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcLampType::declaration() const { return *IfcLampType_type; } Type::Enum IfcLampType::Class() { return Type::IfcLampType; } -IfcLampType::IfcLampType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLampType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLampType::IfcLampType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcLampTypeEnum::IfcLampTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcLampTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcLampType::IfcLampType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLampType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLampType::IfcLampType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcLampTypeEnum::IfcLampTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcLampTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLibraryInformation -std::string IfcLibraryInformation::Name() const { return *entity->getArgument(0); } -void IfcLibraryInformation::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcLibraryInformation::hasVersion() const { return !entity->getArgument(1)->isNull(); } -std::string IfcLibraryInformation::Version() const { return *entity->getArgument(1); } -void IfcLibraryInformation::setVersion(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcLibraryInformation::hasPublisher() const { return !entity->getArgument(2)->isNull(); } -IfcOrganization* IfcLibraryInformation::Publisher() const { return (IfcOrganization*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcLibraryInformation::setPublisher(IfcOrganization* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcLibraryInformation::hasVersionDate() const { return !entity->getArgument(3)->isNull(); } -IfcCalendarDate* IfcLibraryInformation::VersionDate() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcLibraryInformation::setVersionDate(IfcCalendarDate* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcLibraryInformation::hasLibraryReference() const { return !entity->getArgument(4)->isNull(); } -IfcTemplatedEntityList< IfcLibraryReference >::ptr IfcLibraryInformation::LibraryReference() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcLibraryInformation::setLibraryReference(IfcTemplatedEntityList< IfcLibraryReference >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -bool IfcLibraryInformation::is(Type::Enum v) const { return v == Type::IfcLibraryInformation; } -Type::Enum IfcLibraryInformation::type() const { return Type::IfcLibraryInformation; } +std::string IfcLibraryInformation::Name() const { return *data_->getArgument(0); } +void IfcLibraryInformation::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcLibraryInformation::hasVersion() const { return !data_->getArgument(1)->isNull(); } +std::string IfcLibraryInformation::Version() const { return *data_->getArgument(1); } +void IfcLibraryInformation::setVersion(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcLibraryInformation::hasPublisher() const { return !data_->getArgument(2)->isNull(); } +IfcOrganization* IfcLibraryInformation::Publisher() const { return (IfcOrganization*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcLibraryInformation::setPublisher(IfcOrganization* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcLibraryInformation::hasVersionDate() const { return !data_->getArgument(3)->isNull(); } +IfcCalendarDate* IfcLibraryInformation::VersionDate() const { return (IfcCalendarDate*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcLibraryInformation::setVersionDate(IfcCalendarDate* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcLibraryInformation::hasLibraryReference() const { return !data_->getArgument(4)->isNull(); } +IfcTemplatedEntityList< IfcLibraryReference >::ptr IfcLibraryInformation::LibraryReference() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcLibraryInformation::setLibraryReference(IfcTemplatedEntityList< IfcLibraryReference >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } + + +const IfcParse::entity& IfcLibraryInformation::declaration() const { return *IfcLibraryInformation_type; } Type::Enum IfcLibraryInformation::Class() { return Type::IfcLibraryInformation; } -IfcLibraryInformation::IfcLibraryInformation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcLibraryInformation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLibraryInformation::IfcLibraryInformation(std::string v1_Name, boost::optional< std::string > v2_Version, IfcOrganization* v3_Publisher, IfcCalendarDate* v4_VersionDate, boost::optional< IfcTemplatedEntityList< IfcLibraryReference >::ptr > v5_LibraryReference) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Version) { e->setArgument(1,(*v2_Version)); } else { e->setArgument(1); } e->setArgument(2,(v3_Publisher)); e->setArgument(3,(v4_VersionDate)); if (v5_LibraryReference) { e->setArgument(4,(*v5_LibraryReference)->generalize()); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcLibraryInformation::IfcLibraryInformation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcLibraryInformation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLibraryInformation::IfcLibraryInformation(std::string v1_Name, boost::optional< std::string > v2_Version, IfcOrganization* v3_Publisher, IfcCalendarDate* v4_VersionDate, boost::optional< IfcTemplatedEntityList< IfcLibraryReference >::ptr > v5_LibraryReference) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Version) { e->setArgument(1,(*v2_Version)); } else { e->setArgument(1); } e->setArgument(2,(v3_Publisher)); e->setArgument(3,(v4_VersionDate)); if (v5_LibraryReference) { e->setArgument(4,(*v5_LibraryReference)->generalize()); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLibraryReference -IfcLibraryInformation::list::ptr IfcLibraryReference::ReferenceIntoLibrary() const { return entity->getInverse(Type::IfcLibraryInformation, 4)->as(); } -bool IfcLibraryReference::is(Type::Enum v) const { return v == Type::IfcLibraryReference || IfcExternalReference::is(v); } -Type::Enum IfcLibraryReference::type() const { return Type::IfcLibraryReference; } + +IfcLibraryInformation::list::ptr IfcLibraryReference::ReferenceIntoLibrary() const { return data_->getInverse(Type::IfcLibraryInformation, 4)->as(); } + +const IfcParse::entity& IfcLibraryReference::declaration() const { return *IfcLibraryReference_type; } Type::Enum IfcLibraryReference::Class() { return Type::IfcLibraryReference; } -IfcLibraryReference::IfcLibraryReference(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLibraryReference)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLibraryReference::IfcLibraryReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcLibraryReference::IfcLibraryReference(IfcAbstractEntity* e) : IfcExternalReference((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLibraryReference)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLibraryReference::IfcLibraryReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_ItemReference) { e->setArgument(1,(*v2_ItemReference)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLightDistributionData -double IfcLightDistributionData::MainPlaneAngle() const { return *entity->getArgument(0); } -void IfcLightDistributionData::setMainPlaneAngle(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -std::vector< double > /*[1:?]*/ IfcLightDistributionData::SecondaryPlaneAngle() const { return *entity->getArgument(1); } -void IfcLightDistributionData::setSecondaryPlaneAngle(std::vector< double > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -std::vector< double > /*[1:?]*/ IfcLightDistributionData::LuminousIntensity() const { return *entity->getArgument(2); } -void IfcLightDistributionData::setLuminousIntensity(std::vector< double > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcLightDistributionData::is(Type::Enum v) const { return v == Type::IfcLightDistributionData; } -Type::Enum IfcLightDistributionData::type() const { return Type::IfcLightDistributionData; } +double IfcLightDistributionData::MainPlaneAngle() const { return *data_->getArgument(0); } +void IfcLightDistributionData::setMainPlaneAngle(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +std::vector< double > /*[1:?]*/ IfcLightDistributionData::SecondaryPlaneAngle() const { return *data_->getArgument(1); } +void IfcLightDistributionData::setSecondaryPlaneAngle(std::vector< double > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +std::vector< double > /*[1:?]*/ IfcLightDistributionData::LuminousIntensity() const { return *data_->getArgument(2); } +void IfcLightDistributionData::setLuminousIntensity(std::vector< double > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcLightDistributionData::declaration() const { return *IfcLightDistributionData_type; } Type::Enum IfcLightDistributionData::Class() { return Type::IfcLightDistributionData; } -IfcLightDistributionData::IfcLightDistributionData(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcLightDistributionData)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLightDistributionData::IfcLightDistributionData(double v1_MainPlaneAngle, std::vector< double > /*[1:?]*/ v2_SecondaryPlaneAngle, std::vector< double > /*[1:?]*/ v3_LuminousIntensity) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MainPlaneAngle)); e->setArgument(1,(v2_SecondaryPlaneAngle)); e->setArgument(2,(v3_LuminousIntensity)); entity = e; EntityBuffer::Add(this); } +IfcLightDistributionData::IfcLightDistributionData(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcLightDistributionData)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLightDistributionData::IfcLightDistributionData(double v1_MainPlaneAngle, std::vector< double > /*[1:?]*/ v2_SecondaryPlaneAngle, std::vector< double > /*[1:?]*/ v3_LuminousIntensity) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MainPlaneAngle)); e->setArgument(1,(v2_SecondaryPlaneAngle)); e->setArgument(2,(v3_LuminousIntensity)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLightFixtureType -IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum IfcLightFixtureType::PredefinedType() const { return IfcLightFixtureTypeEnum::FromString(*entity->getArgument(9)); } -void IfcLightFixtureType::setPredefinedType(IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcLightFixtureTypeEnum::ToString(v)); } -bool IfcLightFixtureType::is(Type::Enum v) const { return v == Type::IfcLightFixtureType || IfcFlowTerminalType::is(v); } -Type::Enum IfcLightFixtureType::type() const { return Type::IfcLightFixtureType; } +IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum IfcLightFixtureType::PredefinedType() const { return IfcLightFixtureTypeEnum::FromString(*data_->getArgument(9)); } +void IfcLightFixtureType::setPredefinedType(IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcLightFixtureTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcLightFixtureType::declaration() const { return *IfcLightFixtureType_type; } Type::Enum IfcLightFixtureType::Class() { return Type::IfcLightFixtureType; } -IfcLightFixtureType::IfcLightFixtureType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightFixtureType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLightFixtureType::IfcLightFixtureType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcLightFixtureTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcLightFixtureType::IfcLightFixtureType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightFixtureType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLightFixtureType::IfcLightFixtureType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcLightFixtureTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLightIntensityDistribution -IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum IfcLightIntensityDistribution::LightDistributionCurve() const { return IfcLightDistributionCurveEnum::FromString(*entity->getArgument(0)); } -void IfcLightIntensityDistribution::setLightDistributionCurve(IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v,IfcLightDistributionCurveEnum::ToString(v)); } -IfcTemplatedEntityList< IfcLightDistributionData >::ptr IfcLightIntensityDistribution::DistributionData() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcLightIntensityDistribution::setDistributionData(IfcTemplatedEntityList< IfcLightDistributionData >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcLightIntensityDistribution::is(Type::Enum v) const { return v == Type::IfcLightIntensityDistribution; } -Type::Enum IfcLightIntensityDistribution::type() const { return Type::IfcLightIntensityDistribution; } +IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum IfcLightIntensityDistribution::LightDistributionCurve() const { return IfcLightDistributionCurveEnum::FromString(*data_->getArgument(0)); } +void IfcLightIntensityDistribution::setLightDistributionCurve(IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v,IfcLightDistributionCurveEnum::ToString(v)); } +IfcTemplatedEntityList< IfcLightDistributionData >::ptr IfcLightIntensityDistribution::DistributionData() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcLightIntensityDistribution::setDistributionData(IfcTemplatedEntityList< IfcLightDistributionData >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } + + +const IfcParse::entity& IfcLightIntensityDistribution::declaration() const { return *IfcLightIntensityDistribution_type; } Type::Enum IfcLightIntensityDistribution::Class() { return Type::IfcLightIntensityDistribution; } -IfcLightIntensityDistribution::IfcLightIntensityDistribution(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcLightIntensityDistribution)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLightIntensityDistribution::IfcLightIntensityDistribution(IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum v1_LightDistributionCurve, IfcTemplatedEntityList< IfcLightDistributionData >::ptr v2_DistributionData) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_LightDistributionCurve,IfcLightDistributionCurveEnum::ToString(v1_LightDistributionCurve)); e->setArgument(1,(v2_DistributionData)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcLightIntensityDistribution::IfcLightIntensityDistribution(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcLightIntensityDistribution)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLightIntensityDistribution::IfcLightIntensityDistribution(IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum v1_LightDistributionCurve, IfcTemplatedEntityList< IfcLightDistributionData >::ptr v2_DistributionData) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_LightDistributionCurve,IfcLightDistributionCurveEnum::ToString(v1_LightDistributionCurve)); e->setArgument(1,(v2_DistributionData)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLightSource -bool IfcLightSource::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcLightSource::Name() const { return *entity->getArgument(0); } -void IfcLightSource::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcColourRgb* IfcLightSource::LightColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcLightSource::setLightColour(IfcColourRgb* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcLightSource::hasAmbientIntensity() const { return !entity->getArgument(2)->isNull(); } -double IfcLightSource::AmbientIntensity() const { return *entity->getArgument(2); } -void IfcLightSource::setAmbientIntensity(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcLightSource::hasIntensity() const { return !entity->getArgument(3)->isNull(); } -double IfcLightSource::Intensity() const { return *entity->getArgument(3); } -void IfcLightSource::setIntensity(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcLightSource::is(Type::Enum v) const { return v == Type::IfcLightSource || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcLightSource::type() const { return Type::IfcLightSource; } +bool IfcLightSource::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcLightSource::Name() const { return *data_->getArgument(0); } +void IfcLightSource::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcColourRgb* IfcLightSource::LightColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcLightSource::setLightColour(IfcColourRgb* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcLightSource::hasAmbientIntensity() const { return !data_->getArgument(2)->isNull(); } +double IfcLightSource::AmbientIntensity() const { return *data_->getArgument(2); } +void IfcLightSource::setAmbientIntensity(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcLightSource::hasIntensity() const { return !data_->getArgument(3)->isNull(); } +double IfcLightSource::Intensity() const { return *data_->getArgument(3); } +void IfcLightSource::setIntensity(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcLightSource::declaration() const { return *IfcLightSource_type; } Type::Enum IfcLightSource::Class() { return Type::IfcLightSource; } -IfcLightSource::IfcLightSource(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSource)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLightSource::IfcLightSource(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcLightSource::IfcLightSource(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSource)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLightSource::IfcLightSource(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLightSourceAmbient -bool IfcLightSourceAmbient::is(Type::Enum v) const { return v == Type::IfcLightSourceAmbient || IfcLightSource::is(v); } -Type::Enum IfcLightSourceAmbient::type() const { return Type::IfcLightSourceAmbient; } + + +const IfcParse::entity& IfcLightSourceAmbient::declaration() const { return *IfcLightSourceAmbient_type; } Type::Enum IfcLightSourceAmbient::Class() { return Type::IfcLightSourceAmbient; } -IfcLightSourceAmbient::IfcLightSourceAmbient(IfcAbstractEntity* e) : IfcLightSource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSourceAmbient)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLightSourceAmbient::IfcLightSourceAmbient(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity) : IfcLightSource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcLightSourceAmbient::IfcLightSourceAmbient(IfcAbstractEntity* e) : IfcLightSource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSourceAmbient)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLightSourceAmbient::IfcLightSourceAmbient(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity) : IfcLightSource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLightSourceDirectional -IfcDirection* IfcLightSourceDirectional::Orientation() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcLightSourceDirectional::setOrientation(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcLightSourceDirectional::is(Type::Enum v) const { return v == Type::IfcLightSourceDirectional || IfcLightSource::is(v); } -Type::Enum IfcLightSourceDirectional::type() const { return Type::IfcLightSourceDirectional; } +IfcDirection* IfcLightSourceDirectional::Orientation() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcLightSourceDirectional::setOrientation(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcLightSourceDirectional::declaration() const { return *IfcLightSourceDirectional_type; } Type::Enum IfcLightSourceDirectional::Class() { return Type::IfcLightSourceDirectional; } -IfcLightSourceDirectional::IfcLightSourceDirectional(IfcAbstractEntity* e) : IfcLightSource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSourceDirectional)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLightSourceDirectional::IfcLightSourceDirectional(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcDirection* v5_Orientation) : IfcLightSource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } e->setArgument(4,(v5_Orientation)); entity = e; EntityBuffer::Add(this); } +IfcLightSourceDirectional::IfcLightSourceDirectional(IfcAbstractEntity* e) : IfcLightSource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSourceDirectional)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLightSourceDirectional::IfcLightSourceDirectional(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcDirection* v5_Orientation) : IfcLightSource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } e->setArgument(4,(v5_Orientation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLightSourceGoniometric -IfcAxis2Placement3D* IfcLightSourceGoniometric::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcLightSourceGoniometric::setPosition(IfcAxis2Placement3D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcLightSourceGoniometric::hasColourAppearance() const { return !entity->getArgument(5)->isNull(); } -IfcColourRgb* IfcLightSourceGoniometric::ColourAppearance() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcLightSourceGoniometric::setColourAppearance(IfcColourRgb* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcLightSourceGoniometric::ColourTemperature() const { return *entity->getArgument(6); } -void IfcLightSourceGoniometric::setColourTemperature(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -double IfcLightSourceGoniometric::LuminousFlux() const { return *entity->getArgument(7); } -void IfcLightSourceGoniometric::setLuminousFlux(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum IfcLightSourceGoniometric::LightEmissionSource() const { return IfcLightEmissionSourceEnum::FromString(*entity->getArgument(8)); } -void IfcLightSourceGoniometric::setLightEmissionSource(IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcLightEmissionSourceEnum::ToString(v)); } -IfcLightDistributionDataSourceSelect* IfcLightSourceGoniometric::LightDistributionDataSource() const { return (IfcLightDistributionDataSourceSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcLightSourceGoniometric::setLightDistributionDataSource(IfcLightDistributionDataSourceSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcLightSourceGoniometric::is(Type::Enum v) const { return v == Type::IfcLightSourceGoniometric || IfcLightSource::is(v); } -Type::Enum IfcLightSourceGoniometric::type() const { return Type::IfcLightSourceGoniometric; } +IfcAxis2Placement3D* IfcLightSourceGoniometric::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcLightSourceGoniometric::setPosition(IfcAxis2Placement3D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcLightSourceGoniometric::hasColourAppearance() const { return !data_->getArgument(5)->isNull(); } +IfcColourRgb* IfcLightSourceGoniometric::ColourAppearance() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcLightSourceGoniometric::setColourAppearance(IfcColourRgb* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcLightSourceGoniometric::ColourTemperature() const { return *data_->getArgument(6); } +void IfcLightSourceGoniometric::setColourTemperature(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +double IfcLightSourceGoniometric::LuminousFlux() const { return *data_->getArgument(7); } +void IfcLightSourceGoniometric::setLuminousFlux(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum IfcLightSourceGoniometric::LightEmissionSource() const { return IfcLightEmissionSourceEnum::FromString(*data_->getArgument(8)); } +void IfcLightSourceGoniometric::setLightEmissionSource(IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcLightEmissionSourceEnum::ToString(v)); } +IfcLightDistributionDataSourceSelect* IfcLightSourceGoniometric::LightDistributionDataSource() const { return (IfcLightDistributionDataSourceSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcLightSourceGoniometric::setLightDistributionDataSource(IfcLightDistributionDataSourceSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcLightSourceGoniometric::declaration() const { return *IfcLightSourceGoniometric_type; } Type::Enum IfcLightSourceGoniometric::Class() { return Type::IfcLightSourceGoniometric; } -IfcLightSourceGoniometric::IfcLightSourceGoniometric(IfcAbstractEntity* e) : IfcLightSource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSourceGoniometric)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLightSourceGoniometric::IfcLightSourceGoniometric(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcAxis2Placement3D* v5_Position, IfcColourRgb* v6_ColourAppearance, double v7_ColourTemperature, double v8_LuminousFlux, IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum v9_LightEmissionSource, IfcLightDistributionDataSourceSelect* v10_LightDistributionDataSource) : IfcLightSource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } e->setArgument(4,(v5_Position)); e->setArgument(5,(v6_ColourAppearance)); e->setArgument(6,(v7_ColourTemperature)); e->setArgument(7,(v8_LuminousFlux)); e->setArgument(8,v9_LightEmissionSource,IfcLightEmissionSourceEnum::ToString(v9_LightEmissionSource)); e->setArgument(9,(v10_LightDistributionDataSource)); entity = e; EntityBuffer::Add(this); } +IfcLightSourceGoniometric::IfcLightSourceGoniometric(IfcAbstractEntity* e) : IfcLightSource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSourceGoniometric)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLightSourceGoniometric::IfcLightSourceGoniometric(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcAxis2Placement3D* v5_Position, IfcColourRgb* v6_ColourAppearance, double v7_ColourTemperature, double v8_LuminousFlux, IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum v9_LightEmissionSource, IfcLightDistributionDataSourceSelect* v10_LightDistributionDataSource) : IfcLightSource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } e->setArgument(4,(v5_Position)); e->setArgument(5,(v6_ColourAppearance)); e->setArgument(6,(v7_ColourTemperature)); e->setArgument(7,(v8_LuminousFlux)); e->setArgument(8,v9_LightEmissionSource,IfcLightEmissionSourceEnum::ToString(v9_LightEmissionSource)); e->setArgument(9,(v10_LightDistributionDataSource)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLightSourcePositional -IfcCartesianPoint* IfcLightSourcePositional::Position() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcLightSourcePositional::setPosition(IfcCartesianPoint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -double IfcLightSourcePositional::Radius() const { return *entity->getArgument(5); } -void IfcLightSourcePositional::setRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcLightSourcePositional::ConstantAttenuation() const { return *entity->getArgument(6); } -void IfcLightSourcePositional::setConstantAttenuation(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -double IfcLightSourcePositional::DistanceAttenuation() const { return *entity->getArgument(7); } -void IfcLightSourcePositional::setDistanceAttenuation(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -double IfcLightSourcePositional::QuadricAttenuation() const { return *entity->getArgument(8); } -void IfcLightSourcePositional::setQuadricAttenuation(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcLightSourcePositional::is(Type::Enum v) const { return v == Type::IfcLightSourcePositional || IfcLightSource::is(v); } -Type::Enum IfcLightSourcePositional::type() const { return Type::IfcLightSourcePositional; } +IfcCartesianPoint* IfcLightSourcePositional::Position() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcLightSourcePositional::setPosition(IfcCartesianPoint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +double IfcLightSourcePositional::Radius() const { return *data_->getArgument(5); } +void IfcLightSourcePositional::setRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcLightSourcePositional::ConstantAttenuation() const { return *data_->getArgument(6); } +void IfcLightSourcePositional::setConstantAttenuation(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +double IfcLightSourcePositional::DistanceAttenuation() const { return *data_->getArgument(7); } +void IfcLightSourcePositional::setDistanceAttenuation(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +double IfcLightSourcePositional::QuadricAttenuation() const { return *data_->getArgument(8); } +void IfcLightSourcePositional::setQuadricAttenuation(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcLightSourcePositional::declaration() const { return *IfcLightSourcePositional_type; } Type::Enum IfcLightSourcePositional::Class() { return Type::IfcLightSourcePositional; } -IfcLightSourcePositional::IfcLightSourcePositional(IfcAbstractEntity* e) : IfcLightSource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSourcePositional)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLightSourcePositional::IfcLightSourcePositional(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcCartesianPoint* v5_Position, double v6_Radius, double v7_ConstantAttenuation, double v8_DistanceAttenuation, double v9_QuadricAttenuation) : IfcLightSource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } e->setArgument(4,(v5_Position)); e->setArgument(5,(v6_Radius)); e->setArgument(6,(v7_ConstantAttenuation)); e->setArgument(7,(v8_DistanceAttenuation)); e->setArgument(8,(v9_QuadricAttenuation)); entity = e; EntityBuffer::Add(this); } +IfcLightSourcePositional::IfcLightSourcePositional(IfcAbstractEntity* e) : IfcLightSource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSourcePositional)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLightSourcePositional::IfcLightSourcePositional(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcCartesianPoint* v5_Position, double v6_Radius, double v7_ConstantAttenuation, double v8_DistanceAttenuation, double v9_QuadricAttenuation) : IfcLightSource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } e->setArgument(4,(v5_Position)); e->setArgument(5,(v6_Radius)); e->setArgument(6,(v7_ConstantAttenuation)); e->setArgument(7,(v8_DistanceAttenuation)); e->setArgument(8,(v9_QuadricAttenuation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLightSourceSpot -IfcDirection* IfcLightSourceSpot::Orientation() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcLightSourceSpot::setOrientation(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcLightSourceSpot::hasConcentrationExponent() const { return !entity->getArgument(10)->isNull(); } -double IfcLightSourceSpot::ConcentrationExponent() const { return *entity->getArgument(10); } -void IfcLightSourceSpot::setConcentrationExponent(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -double IfcLightSourceSpot::SpreadAngle() const { return *entity->getArgument(11); } -void IfcLightSourceSpot::setSpreadAngle(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -double IfcLightSourceSpot::BeamWidthAngle() const { return *entity->getArgument(12); } -void IfcLightSourceSpot::setBeamWidthAngle(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcLightSourceSpot::is(Type::Enum v) const { return v == Type::IfcLightSourceSpot || IfcLightSourcePositional::is(v); } -Type::Enum IfcLightSourceSpot::type() const { return Type::IfcLightSourceSpot; } +IfcDirection* IfcLightSourceSpot::Orientation() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcLightSourceSpot::setOrientation(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcLightSourceSpot::hasConcentrationExponent() const { return !data_->getArgument(10)->isNull(); } +double IfcLightSourceSpot::ConcentrationExponent() const { return *data_->getArgument(10); } +void IfcLightSourceSpot::setConcentrationExponent(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +double IfcLightSourceSpot::SpreadAngle() const { return *data_->getArgument(11); } +void IfcLightSourceSpot::setSpreadAngle(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +double IfcLightSourceSpot::BeamWidthAngle() const { return *data_->getArgument(12); } +void IfcLightSourceSpot::setBeamWidthAngle(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } + + +const IfcParse::entity& IfcLightSourceSpot::declaration() const { return *IfcLightSourceSpot_type; } Type::Enum IfcLightSourceSpot::Class() { return Type::IfcLightSourceSpot; } -IfcLightSourceSpot::IfcLightSourceSpot(IfcAbstractEntity* e) : IfcLightSourcePositional((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSourceSpot)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLightSourceSpot::IfcLightSourceSpot(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcCartesianPoint* v5_Position, double v6_Radius, double v7_ConstantAttenuation, double v8_DistanceAttenuation, double v9_QuadricAttenuation, IfcDirection* v10_Orientation, boost::optional< double > v11_ConcentrationExponent, double v12_SpreadAngle, double v13_BeamWidthAngle) : IfcLightSourcePositional((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } e->setArgument(4,(v5_Position)); e->setArgument(5,(v6_Radius)); e->setArgument(6,(v7_ConstantAttenuation)); e->setArgument(7,(v8_DistanceAttenuation)); e->setArgument(8,(v9_QuadricAttenuation)); e->setArgument(9,(v10_Orientation)); if (v11_ConcentrationExponent) { e->setArgument(10,(*v11_ConcentrationExponent)); } else { e->setArgument(10); } e->setArgument(11,(v12_SpreadAngle)); e->setArgument(12,(v13_BeamWidthAngle)); entity = e; EntityBuffer::Add(this); } +IfcLightSourceSpot::IfcLightSourceSpot(IfcAbstractEntity* e) : IfcLightSourcePositional((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightSourceSpot)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLightSourceSpot::IfcLightSourceSpot(boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcCartesianPoint* v5_Position, double v6_Radius, double v7_ConstantAttenuation, double v8_DistanceAttenuation, double v9_QuadricAttenuation, IfcDirection* v10_Orientation, boost::optional< double > v11_ConcentrationExponent, double v12_SpreadAngle, double v13_BeamWidthAngle) : IfcLightSourcePositional((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_LightColour)); if (v3_AmbientIntensity) { e->setArgument(2,(*v3_AmbientIntensity)); } else { e->setArgument(2); } if (v4_Intensity) { e->setArgument(3,(*v4_Intensity)); } else { e->setArgument(3); } e->setArgument(4,(v5_Position)); e->setArgument(5,(v6_Radius)); e->setArgument(6,(v7_ConstantAttenuation)); e->setArgument(7,(v8_DistanceAttenuation)); e->setArgument(8,(v9_QuadricAttenuation)); e->setArgument(9,(v10_Orientation)); if (v11_ConcentrationExponent) { e->setArgument(10,(*v11_ConcentrationExponent)); } else { e->setArgument(10); } e->setArgument(11,(v12_SpreadAngle)); e->setArgument(12,(v13_BeamWidthAngle)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLine -IfcCartesianPoint* IfcLine::Pnt() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcLine::setPnt(IfcCartesianPoint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcVector* IfcLine::Dir() const { return (IfcVector*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcLine::setDir(IfcVector* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcLine::is(Type::Enum v) const { return v == Type::IfcLine || IfcCurve::is(v); } -Type::Enum IfcLine::type() const { return Type::IfcLine; } +IfcCartesianPoint* IfcLine::Pnt() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcLine::setPnt(IfcCartesianPoint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcVector* IfcLine::Dir() const { return (IfcVector*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcLine::setDir(IfcVector* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcLine::declaration() const { return *IfcLine_type; } Type::Enum IfcLine::Class() { return Type::IfcLine; } -IfcLine::IfcLine(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLine)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLine::IfcLine(IfcCartesianPoint* v1_Pnt, IfcVector* v2_Dir) : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Pnt)); e->setArgument(1,(v2_Dir)); entity = e; EntityBuffer::Add(this); } +IfcLine::IfcLine(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLine)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLine::IfcLine(IfcCartesianPoint* v1_Pnt, IfcVector* v2_Dir) : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Pnt)); e->setArgument(1,(v2_Dir)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLinearDimension -bool IfcLinearDimension::is(Type::Enum v) const { return v == Type::IfcLinearDimension || IfcDimensionCurveDirectedCallout::is(v); } -Type::Enum IfcLinearDimension::type() const { return Type::IfcLinearDimension; } + + +const IfcParse::entity& IfcLinearDimension::declaration() const { return *IfcLinearDimension_type; } Type::Enum IfcLinearDimension::Class() { return Type::IfcLinearDimension; } -IfcLinearDimension::IfcLinearDimension(IfcAbstractEntity* e) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLinearDimension)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLinearDimension::IfcLinearDimension(IfcEntityList::ptr v1_Contents) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); entity = e; EntityBuffer::Add(this); } +IfcLinearDimension::IfcLinearDimension(IfcAbstractEntity* e) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLinearDimension)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLinearDimension::IfcLinearDimension(IfcEntityList::ptr v1_Contents) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLocalPlacement -bool IfcLocalPlacement::hasPlacementRelTo() const { return !entity->getArgument(0)->isNull(); } -IfcObjectPlacement* IfcLocalPlacement::PlacementRelTo() const { return (IfcObjectPlacement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcLocalPlacement::setPlacementRelTo(IfcObjectPlacement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcAxis2Placement* IfcLocalPlacement::RelativePlacement() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcLocalPlacement::setRelativePlacement(IfcAxis2Placement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcLocalPlacement::is(Type::Enum v) const { return v == Type::IfcLocalPlacement || IfcObjectPlacement::is(v); } -Type::Enum IfcLocalPlacement::type() const { return Type::IfcLocalPlacement; } +bool IfcLocalPlacement::hasPlacementRelTo() const { return !data_->getArgument(0)->isNull(); } +IfcObjectPlacement* IfcLocalPlacement::PlacementRelTo() const { return (IfcObjectPlacement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcLocalPlacement::setPlacementRelTo(IfcObjectPlacement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcAxis2Placement* IfcLocalPlacement::RelativePlacement() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcLocalPlacement::setRelativePlacement(IfcAxis2Placement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcLocalPlacement::declaration() const { return *IfcLocalPlacement_type; } Type::Enum IfcLocalPlacement::Class() { return Type::IfcLocalPlacement; } -IfcLocalPlacement::IfcLocalPlacement(IfcAbstractEntity* e) : IfcObjectPlacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLocalPlacement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLocalPlacement::IfcLocalPlacement(IfcObjectPlacement* v1_PlacementRelTo, IfcAxis2Placement* v2_RelativePlacement) : IfcObjectPlacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_PlacementRelTo)); e->setArgument(1,(v2_RelativePlacement)); entity = e; EntityBuffer::Add(this); } +IfcLocalPlacement::IfcLocalPlacement(IfcAbstractEntity* e) : IfcObjectPlacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLocalPlacement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLocalPlacement::IfcLocalPlacement(IfcObjectPlacement* v1_PlacementRelTo, IfcAxis2Placement* v2_RelativePlacement) : IfcObjectPlacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_PlacementRelTo)); e->setArgument(1,(v2_RelativePlacement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLocalTime -int IfcLocalTime::HourComponent() const { return *entity->getArgument(0); } -void IfcLocalTime::setHourComponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcLocalTime::hasMinuteComponent() const { return !entity->getArgument(1)->isNull(); } -int IfcLocalTime::MinuteComponent() const { return *entity->getArgument(1); } -void IfcLocalTime::setMinuteComponent(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcLocalTime::hasSecondComponent() const { return !entity->getArgument(2)->isNull(); } -double IfcLocalTime::SecondComponent() const { return *entity->getArgument(2); } -void IfcLocalTime::setSecondComponent(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcLocalTime::hasZone() const { return !entity->getArgument(3)->isNull(); } -IfcCoordinatedUniversalTimeOffset* IfcLocalTime::Zone() const { return (IfcCoordinatedUniversalTimeOffset*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcLocalTime::setZone(IfcCoordinatedUniversalTimeOffset* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcLocalTime::hasDaylightSavingOffset() const { return !entity->getArgument(4)->isNull(); } -int IfcLocalTime::DaylightSavingOffset() const { return *entity->getArgument(4); } -void IfcLocalTime::setDaylightSavingOffset(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcLocalTime::is(Type::Enum v) const { return v == Type::IfcLocalTime; } -Type::Enum IfcLocalTime::type() const { return Type::IfcLocalTime; } +int IfcLocalTime::HourComponent() const { return *data_->getArgument(0); } +void IfcLocalTime::setHourComponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcLocalTime::hasMinuteComponent() const { return !data_->getArgument(1)->isNull(); } +int IfcLocalTime::MinuteComponent() const { return *data_->getArgument(1); } +void IfcLocalTime::setMinuteComponent(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcLocalTime::hasSecondComponent() const { return !data_->getArgument(2)->isNull(); } +double IfcLocalTime::SecondComponent() const { return *data_->getArgument(2); } +void IfcLocalTime::setSecondComponent(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcLocalTime::hasZone() const { return !data_->getArgument(3)->isNull(); } +IfcCoordinatedUniversalTimeOffset* IfcLocalTime::Zone() const { return (IfcCoordinatedUniversalTimeOffset*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcLocalTime::setZone(IfcCoordinatedUniversalTimeOffset* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcLocalTime::hasDaylightSavingOffset() const { return !data_->getArgument(4)->isNull(); } +int IfcLocalTime::DaylightSavingOffset() const { return *data_->getArgument(4); } +void IfcLocalTime::setDaylightSavingOffset(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcLocalTime::declaration() const { return *IfcLocalTime_type; } Type::Enum IfcLocalTime::Class() { return Type::IfcLocalTime; } -IfcLocalTime::IfcLocalTime(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcLocalTime)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLocalTime::IfcLocalTime(int v1_HourComponent, boost::optional< int > v2_MinuteComponent, boost::optional< double > v3_SecondComponent, IfcCoordinatedUniversalTimeOffset* v4_Zone, boost::optional< int > v5_DaylightSavingOffset) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_HourComponent)); if (v2_MinuteComponent) { e->setArgument(1,(*v2_MinuteComponent)); } else { e->setArgument(1); } if (v3_SecondComponent) { e->setArgument(2,(*v3_SecondComponent)); } else { e->setArgument(2); } e->setArgument(3,(v4_Zone)); if (v5_DaylightSavingOffset) { e->setArgument(4,(*v5_DaylightSavingOffset)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcLocalTime::IfcLocalTime(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcLocalTime)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLocalTime::IfcLocalTime(int v1_HourComponent, boost::optional< int > v2_MinuteComponent, boost::optional< double > v3_SecondComponent, IfcCoordinatedUniversalTimeOffset* v4_Zone, boost::optional< int > v5_DaylightSavingOffset) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_HourComponent)); if (v2_MinuteComponent) { e->setArgument(1,(*v2_MinuteComponent)); } else { e->setArgument(1); } if (v3_SecondComponent) { e->setArgument(2,(*v3_SecondComponent)); } else { e->setArgument(2); } e->setArgument(3,(v4_Zone)); if (v5_DaylightSavingOffset) { e->setArgument(4,(*v5_DaylightSavingOffset)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLoop -bool IfcLoop::is(Type::Enum v) const { return v == Type::IfcLoop || IfcTopologicalRepresentationItem::is(v); } -Type::Enum IfcLoop::type() const { return Type::IfcLoop; } + + +const IfcParse::entity& IfcLoop::declaration() const { return *IfcLoop_type; } Type::Enum IfcLoop::Class() { return Type::IfcLoop; } -IfcLoop::IfcLoop(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLoop)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLoop::IfcLoop() : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcLoop::IfcLoop(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLoop)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLoop::IfcLoop() : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcManifoldSolidBrep -IfcClosedShell* IfcManifoldSolidBrep::Outer() const { return (IfcClosedShell*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcManifoldSolidBrep::setOuter(IfcClosedShell* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcManifoldSolidBrep::is(Type::Enum v) const { return v == Type::IfcManifoldSolidBrep || IfcSolidModel::is(v); } -Type::Enum IfcManifoldSolidBrep::type() const { return Type::IfcManifoldSolidBrep; } +IfcClosedShell* IfcManifoldSolidBrep::Outer() const { return (IfcClosedShell*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcManifoldSolidBrep::setOuter(IfcClosedShell* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcManifoldSolidBrep::declaration() const { return *IfcManifoldSolidBrep_type; } Type::Enum IfcManifoldSolidBrep::Class() { return Type::IfcManifoldSolidBrep; } -IfcManifoldSolidBrep::IfcManifoldSolidBrep(IfcAbstractEntity* e) : IfcSolidModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcManifoldSolidBrep)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcManifoldSolidBrep::IfcManifoldSolidBrep(IfcClosedShell* v1_Outer) : IfcSolidModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Outer)); entity = e; EntityBuffer::Add(this); } +IfcManifoldSolidBrep::IfcManifoldSolidBrep(IfcAbstractEntity* e) : IfcSolidModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcManifoldSolidBrep)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcManifoldSolidBrep::IfcManifoldSolidBrep(IfcClosedShell* v1_Outer) : IfcSolidModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Outer)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMappedItem -IfcRepresentationMap* IfcMappedItem::MappingSource() const { return (IfcRepresentationMap*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcMappedItem::setMappingSource(IfcRepresentationMap* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcCartesianTransformationOperator* IfcMappedItem::MappingTarget() const { return (IfcCartesianTransformationOperator*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcMappedItem::setMappingTarget(IfcCartesianTransformationOperator* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcMappedItem::is(Type::Enum v) const { return v == Type::IfcMappedItem || IfcRepresentationItem::is(v); } -Type::Enum IfcMappedItem::type() const { return Type::IfcMappedItem; } +IfcRepresentationMap* IfcMappedItem::MappingSource() const { return (IfcRepresentationMap*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcMappedItem::setMappingSource(IfcRepresentationMap* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcCartesianTransformationOperator* IfcMappedItem::MappingTarget() const { return (IfcCartesianTransformationOperator*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcMappedItem::setMappingTarget(IfcCartesianTransformationOperator* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcMappedItem::declaration() const { return *IfcMappedItem_type; } Type::Enum IfcMappedItem::Class() { return Type::IfcMappedItem; } -IfcMappedItem::IfcMappedItem(IfcAbstractEntity* e) : IfcRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMappedItem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMappedItem::IfcMappedItem(IfcRepresentationMap* v1_MappingSource, IfcCartesianTransformationOperator* v2_MappingTarget) : IfcRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MappingSource)); e->setArgument(1,(v2_MappingTarget)); entity = e; EntityBuffer::Add(this); } +IfcMappedItem::IfcMappedItem(IfcAbstractEntity* e) : IfcRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMappedItem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMappedItem::IfcMappedItem(IfcRepresentationMap* v1_MappingSource, IfcCartesianTransformationOperator* v2_MappingTarget) : IfcRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MappingSource)); e->setArgument(1,(v2_MappingTarget)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterial -std::string IfcMaterial::Name() const { return *entity->getArgument(0); } -void IfcMaterial::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcMaterialDefinitionRepresentation::list::ptr IfcMaterial::HasRepresentation() const { return entity->getInverse(Type::IfcMaterialDefinitionRepresentation, 3)->as(); } -IfcMaterialClassificationRelationship::list::ptr IfcMaterial::ClassifiedAs() const { return entity->getInverse(Type::IfcMaterialClassificationRelationship, 1)->as(); } -bool IfcMaterial::is(Type::Enum v) const { return v == Type::IfcMaterial; } -Type::Enum IfcMaterial::type() const { return Type::IfcMaterial; } +std::string IfcMaterial::Name() const { return *data_->getArgument(0); } +void IfcMaterial::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + +IfcMaterialDefinitionRepresentation::list::ptr IfcMaterial::HasRepresentation() const { return data_->getInverse(Type::IfcMaterialDefinitionRepresentation, 3)->as(); } +IfcMaterialClassificationRelationship::list::ptr IfcMaterial::ClassifiedAs() const { return data_->getInverse(Type::IfcMaterialClassificationRelationship, 1)->as(); } + +const IfcParse::entity& IfcMaterial::declaration() const { return *IfcMaterial_type; } Type::Enum IfcMaterial::Class() { return Type::IfcMaterial; } -IfcMaterial::IfcMaterial(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterial)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterial::IfcMaterial(std::string v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcMaterial::IfcMaterial(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterial)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterial::IfcMaterial(std::string v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialClassificationRelationship -IfcEntityList::ptr IfcMaterialClassificationRelationship::MaterialClassifications() const { return *entity->getArgument(0); } -void IfcMaterialClassificationRelationship::setMaterialClassifications(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcMaterial* IfcMaterialClassificationRelationship::ClassifiedMaterial() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcMaterialClassificationRelationship::setClassifiedMaterial(IfcMaterial* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcMaterialClassificationRelationship::is(Type::Enum v) const { return v == Type::IfcMaterialClassificationRelationship; } -Type::Enum IfcMaterialClassificationRelationship::type() const { return Type::IfcMaterialClassificationRelationship; } +IfcEntityList::ptr IfcMaterialClassificationRelationship::MaterialClassifications() const { return *data_->getArgument(0); } +void IfcMaterialClassificationRelationship::setMaterialClassifications(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcMaterial* IfcMaterialClassificationRelationship::ClassifiedMaterial() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcMaterialClassificationRelationship::setClassifiedMaterial(IfcMaterial* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcMaterialClassificationRelationship::declaration() const { return *IfcMaterialClassificationRelationship_type; } Type::Enum IfcMaterialClassificationRelationship::Class() { return Type::IfcMaterialClassificationRelationship; } -IfcMaterialClassificationRelationship::IfcMaterialClassificationRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialClassificationRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialClassificationRelationship::IfcMaterialClassificationRelationship(IfcEntityList::ptr v1_MaterialClassifications, IfcMaterial* v2_ClassifiedMaterial) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MaterialClassifications)); e->setArgument(1,(v2_ClassifiedMaterial)); entity = e; EntityBuffer::Add(this); } +IfcMaterialClassificationRelationship::IfcMaterialClassificationRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialClassificationRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialClassificationRelationship::IfcMaterialClassificationRelationship(IfcEntityList::ptr v1_MaterialClassifications, IfcMaterial* v2_ClassifiedMaterial) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MaterialClassifications)); e->setArgument(1,(v2_ClassifiedMaterial)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialDefinitionRepresentation -IfcMaterial* IfcMaterialDefinitionRepresentation::RepresentedMaterial() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcMaterialDefinitionRepresentation::setRepresentedMaterial(IfcMaterial* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcMaterialDefinitionRepresentation::is(Type::Enum v) const { return v == Type::IfcMaterialDefinitionRepresentation || IfcProductRepresentation::is(v); } -Type::Enum IfcMaterialDefinitionRepresentation::type() const { return Type::IfcMaterialDefinitionRepresentation; } +IfcMaterial* IfcMaterialDefinitionRepresentation::RepresentedMaterial() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcMaterialDefinitionRepresentation::setRepresentedMaterial(IfcMaterial* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcMaterialDefinitionRepresentation::declaration() const { return *IfcMaterialDefinitionRepresentation_type; } Type::Enum IfcMaterialDefinitionRepresentation::Class() { return Type::IfcMaterialDefinitionRepresentation; } -IfcMaterialDefinitionRepresentation::IfcMaterialDefinitionRepresentation(IfcAbstractEntity* e) : IfcProductRepresentation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialDefinitionRepresentation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialDefinitionRepresentation::IfcMaterialDefinitionRepresentation(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcRepresentation >::ptr v3_Representations, IfcMaterial* v4_RepresentedMaterial) : IfcProductRepresentation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Representations)->generalize()); e->setArgument(3,(v4_RepresentedMaterial)); entity = e; EntityBuffer::Add(this); } +IfcMaterialDefinitionRepresentation::IfcMaterialDefinitionRepresentation(IfcAbstractEntity* e) : IfcProductRepresentation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialDefinitionRepresentation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialDefinitionRepresentation::IfcMaterialDefinitionRepresentation(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcRepresentation >::ptr v3_Representations, IfcMaterial* v4_RepresentedMaterial) : IfcProductRepresentation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Representations)->generalize()); e->setArgument(3,(v4_RepresentedMaterial)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialLayer -bool IfcMaterialLayer::hasMaterial() const { return !entity->getArgument(0)->isNull(); } -IfcMaterial* IfcMaterialLayer::Material() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcMaterialLayer::setMaterial(IfcMaterial* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcMaterialLayer::LayerThickness() const { return *entity->getArgument(1); } -void IfcMaterialLayer::setLayerThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcMaterialLayer::hasIsVentilated() const { return !entity->getArgument(2)->isNull(); } -bool IfcMaterialLayer::IsVentilated() const { return *entity->getArgument(2); } -void IfcMaterialLayer::setIsVentilated(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcMaterialLayerSet::list::ptr IfcMaterialLayer::ToMaterialLayerSet() const { return entity->getInverse(Type::IfcMaterialLayerSet, 0)->as(); } -bool IfcMaterialLayer::is(Type::Enum v) const { return v == Type::IfcMaterialLayer; } -Type::Enum IfcMaterialLayer::type() const { return Type::IfcMaterialLayer; } +bool IfcMaterialLayer::hasMaterial() const { return !data_->getArgument(0)->isNull(); } +IfcMaterial* IfcMaterialLayer::Material() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcMaterialLayer::setMaterial(IfcMaterial* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcMaterialLayer::LayerThickness() const { return *data_->getArgument(1); } +void IfcMaterialLayer::setLayerThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcMaterialLayer::hasIsVentilated() const { return !data_->getArgument(2)->isNull(); } +bool IfcMaterialLayer::IsVentilated() const { return *data_->getArgument(2); } +void IfcMaterialLayer::setIsVentilated(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + +IfcMaterialLayerSet::list::ptr IfcMaterialLayer::ToMaterialLayerSet() const { return data_->getInverse(Type::IfcMaterialLayerSet, 0)->as(); } + +const IfcParse::entity& IfcMaterialLayer::declaration() const { return *IfcMaterialLayer_type; } Type::Enum IfcMaterialLayer::Class() { return Type::IfcMaterialLayer; } -IfcMaterialLayer::IfcMaterialLayer(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialLayer)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialLayer::IfcMaterialLayer(IfcMaterial* v1_Material, double v2_LayerThickness, boost::optional< bool > v3_IsVentilated) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); e->setArgument(1,(v2_LayerThickness)); if (v3_IsVentilated) { e->setArgument(2,(*v3_IsVentilated)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcMaterialLayer::IfcMaterialLayer(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialLayer)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialLayer::IfcMaterialLayer(IfcMaterial* v1_Material, double v2_LayerThickness, boost::optional< bool > v3_IsVentilated) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); e->setArgument(1,(v2_LayerThickness)); if (v3_IsVentilated) { e->setArgument(2,(*v3_IsVentilated)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialLayerSet -IfcTemplatedEntityList< IfcMaterialLayer >::ptr IfcMaterialLayerSet::MaterialLayers() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcMaterialLayerSet::setMaterialLayers(IfcTemplatedEntityList< IfcMaterialLayer >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcMaterialLayerSet::hasLayerSetName() const { return !entity->getArgument(1)->isNull(); } -std::string IfcMaterialLayerSet::LayerSetName() const { return *entity->getArgument(1); } -void IfcMaterialLayerSet::setLayerSetName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcMaterialLayerSet::is(Type::Enum v) const { return v == Type::IfcMaterialLayerSet; } -Type::Enum IfcMaterialLayerSet::type() const { return Type::IfcMaterialLayerSet; } +IfcTemplatedEntityList< IfcMaterialLayer >::ptr IfcMaterialLayerSet::MaterialLayers() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcMaterialLayerSet::setMaterialLayers(IfcTemplatedEntityList< IfcMaterialLayer >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } +bool IfcMaterialLayerSet::hasLayerSetName() const { return !data_->getArgument(1)->isNull(); } +std::string IfcMaterialLayerSet::LayerSetName() const { return *data_->getArgument(1); } +void IfcMaterialLayerSet::setLayerSetName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcMaterialLayerSet::declaration() const { return *IfcMaterialLayerSet_type; } Type::Enum IfcMaterialLayerSet::Class() { return Type::IfcMaterialLayerSet; } -IfcMaterialLayerSet::IfcMaterialLayerSet(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialLayerSet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialLayerSet::IfcMaterialLayerSet(IfcTemplatedEntityList< IfcMaterialLayer >::ptr v1_MaterialLayers, boost::optional< std::string > v2_LayerSetName) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MaterialLayers)->generalize()); if (v2_LayerSetName) { e->setArgument(1,(*v2_LayerSetName)); } else { e->setArgument(1); } entity = e; EntityBuffer::Add(this); } +IfcMaterialLayerSet::IfcMaterialLayerSet(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialLayerSet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialLayerSet::IfcMaterialLayerSet(IfcTemplatedEntityList< IfcMaterialLayer >::ptr v1_MaterialLayers, boost::optional< std::string > v2_LayerSetName) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MaterialLayers)->generalize()); if (v2_LayerSetName) { e->setArgument(1,(*v2_LayerSetName)); } else { e->setArgument(1); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialLayerSetUsage -IfcMaterialLayerSet* IfcMaterialLayerSetUsage::ForLayerSet() const { return (IfcMaterialLayerSet*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcMaterialLayerSetUsage::setForLayerSet(IfcMaterialLayerSet* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum IfcMaterialLayerSetUsage::LayerSetDirection() const { return IfcLayerSetDirectionEnum::FromString(*entity->getArgument(1)); } -void IfcMaterialLayerSetUsage::setLayerSetDirection(IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v,IfcLayerSetDirectionEnum::ToString(v)); } -IfcDirectionSenseEnum::IfcDirectionSenseEnum IfcMaterialLayerSetUsage::DirectionSense() const { return IfcDirectionSenseEnum::FromString(*entity->getArgument(2)); } -void IfcMaterialLayerSetUsage::setDirectionSense(IfcDirectionSenseEnum::IfcDirectionSenseEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v,IfcDirectionSenseEnum::ToString(v)); } -double IfcMaterialLayerSetUsage::OffsetFromReferenceLine() const { return *entity->getArgument(3); } -void IfcMaterialLayerSetUsage::setOffsetFromReferenceLine(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcMaterialLayerSetUsage::is(Type::Enum v) const { return v == Type::IfcMaterialLayerSetUsage; } -Type::Enum IfcMaterialLayerSetUsage::type() const { return Type::IfcMaterialLayerSetUsage; } +IfcMaterialLayerSet* IfcMaterialLayerSetUsage::ForLayerSet() const { return (IfcMaterialLayerSet*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcMaterialLayerSetUsage::setForLayerSet(IfcMaterialLayerSet* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum IfcMaterialLayerSetUsage::LayerSetDirection() const { return IfcLayerSetDirectionEnum::FromString(*data_->getArgument(1)); } +void IfcMaterialLayerSetUsage::setLayerSetDirection(IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v,IfcLayerSetDirectionEnum::ToString(v)); } +IfcDirectionSenseEnum::IfcDirectionSenseEnum IfcMaterialLayerSetUsage::DirectionSense() const { return IfcDirectionSenseEnum::FromString(*data_->getArgument(2)); } +void IfcMaterialLayerSetUsage::setDirectionSense(IfcDirectionSenseEnum::IfcDirectionSenseEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v,IfcDirectionSenseEnum::ToString(v)); } +double IfcMaterialLayerSetUsage::OffsetFromReferenceLine() const { return *data_->getArgument(3); } +void IfcMaterialLayerSetUsage::setOffsetFromReferenceLine(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcMaterialLayerSetUsage::declaration() const { return *IfcMaterialLayerSetUsage_type; } Type::Enum IfcMaterialLayerSetUsage::Class() { return Type::IfcMaterialLayerSetUsage; } -IfcMaterialLayerSetUsage::IfcMaterialLayerSetUsage(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialLayerSetUsage)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialLayerSetUsage::IfcMaterialLayerSetUsage(IfcMaterialLayerSet* v1_ForLayerSet, IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum v2_LayerSetDirection, IfcDirectionSenseEnum::IfcDirectionSenseEnum v3_DirectionSense, double v4_OffsetFromReferenceLine) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ForLayerSet)); e->setArgument(1,v2_LayerSetDirection,IfcLayerSetDirectionEnum::ToString(v2_LayerSetDirection)); e->setArgument(2,v3_DirectionSense,IfcDirectionSenseEnum::ToString(v3_DirectionSense)); e->setArgument(3,(v4_OffsetFromReferenceLine)); entity = e; EntityBuffer::Add(this); } +IfcMaterialLayerSetUsage::IfcMaterialLayerSetUsage(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialLayerSetUsage)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialLayerSetUsage::IfcMaterialLayerSetUsage(IfcMaterialLayerSet* v1_ForLayerSet, IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum v2_LayerSetDirection, IfcDirectionSenseEnum::IfcDirectionSenseEnum v3_DirectionSense, double v4_OffsetFromReferenceLine) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ForLayerSet)); e->setArgument(1,v2_LayerSetDirection,IfcLayerSetDirectionEnum::ToString(v2_LayerSetDirection)); e->setArgument(2,v3_DirectionSense,IfcDirectionSenseEnum::ToString(v3_DirectionSense)); e->setArgument(3,(v4_OffsetFromReferenceLine)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialList -IfcTemplatedEntityList< IfcMaterial >::ptr IfcMaterialList::Materials() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcMaterialList::setMaterials(IfcTemplatedEntityList< IfcMaterial >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcMaterialList::is(Type::Enum v) const { return v == Type::IfcMaterialList; } -Type::Enum IfcMaterialList::type() const { return Type::IfcMaterialList; } +IfcTemplatedEntityList< IfcMaterial >::ptr IfcMaterialList::Materials() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcMaterialList::setMaterials(IfcTemplatedEntityList< IfcMaterial >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcMaterialList::declaration() const { return *IfcMaterialList_type; } Type::Enum IfcMaterialList::Class() { return Type::IfcMaterialList; } -IfcMaterialList::IfcMaterialList(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialList)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialList::IfcMaterialList(IfcTemplatedEntityList< IfcMaterial >::ptr v1_Materials) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Materials)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcMaterialList::IfcMaterialList(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialList)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialList::IfcMaterialList(IfcTemplatedEntityList< IfcMaterial >::ptr v1_Materials) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Materials)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialProperties -IfcMaterial* IfcMaterialProperties::Material() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcMaterialProperties::setMaterial(IfcMaterial* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcMaterialProperties::is(Type::Enum v) const { return v == Type::IfcMaterialProperties; } -Type::Enum IfcMaterialProperties::type() const { return Type::IfcMaterialProperties; } +IfcMaterial* IfcMaterialProperties::Material() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcMaterialProperties::setMaterial(IfcMaterial* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcMaterialProperties::declaration() const { return *IfcMaterialProperties_type; } Type::Enum IfcMaterialProperties::Class() { return Type::IfcMaterialProperties; } -IfcMaterialProperties::IfcMaterialProperties(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialProperties::IfcMaterialProperties(IfcMaterial* v1_Material) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); entity = e; EntityBuffer::Add(this); } +IfcMaterialProperties::IfcMaterialProperties(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialProperties::IfcMaterialProperties(IfcMaterial* v1_Material) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMeasureWithUnit -IfcValue* IfcMeasureWithUnit::ValueComponent() const { return (IfcValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcMeasureWithUnit::setValueComponent(IfcValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcUnit* IfcMeasureWithUnit::UnitComponent() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcMeasureWithUnit::setUnitComponent(IfcUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcMeasureWithUnit::is(Type::Enum v) const { return v == Type::IfcMeasureWithUnit; } -Type::Enum IfcMeasureWithUnit::type() const { return Type::IfcMeasureWithUnit; } +IfcValue* IfcMeasureWithUnit::ValueComponent() const { return (IfcValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcMeasureWithUnit::setValueComponent(IfcValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcUnit* IfcMeasureWithUnit::UnitComponent() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcMeasureWithUnit::setUnitComponent(IfcUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcMeasureWithUnit::declaration() const { return *IfcMeasureWithUnit_type; } Type::Enum IfcMeasureWithUnit::Class() { return Type::IfcMeasureWithUnit; } -IfcMeasureWithUnit::IfcMeasureWithUnit(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMeasureWithUnit)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMeasureWithUnit::IfcMeasureWithUnit(IfcValue* v1_ValueComponent, IfcUnit* v2_UnitComponent) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ValueComponent)); e->setArgument(1,(v2_UnitComponent)); entity = e; EntityBuffer::Add(this); } +IfcMeasureWithUnit::IfcMeasureWithUnit(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMeasureWithUnit)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMeasureWithUnit::IfcMeasureWithUnit(IfcValue* v1_ValueComponent, IfcUnit* v2_UnitComponent) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ValueComponent)); e->setArgument(1,(v2_UnitComponent)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMechanicalConcreteMaterialProperties -bool IfcMechanicalConcreteMaterialProperties::hasCompressiveStrength() const { return !entity->getArgument(6)->isNull(); } -double IfcMechanicalConcreteMaterialProperties::CompressiveStrength() const { return *entity->getArgument(6); } -void IfcMechanicalConcreteMaterialProperties::setCompressiveStrength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcMechanicalConcreteMaterialProperties::hasMaxAggregateSize() const { return !entity->getArgument(7)->isNull(); } -double IfcMechanicalConcreteMaterialProperties::MaxAggregateSize() const { return *entity->getArgument(7); } -void IfcMechanicalConcreteMaterialProperties::setMaxAggregateSize(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcMechanicalConcreteMaterialProperties::hasAdmixturesDescription() const { return !entity->getArgument(8)->isNull(); } -std::string IfcMechanicalConcreteMaterialProperties::AdmixturesDescription() const { return *entity->getArgument(8); } -void IfcMechanicalConcreteMaterialProperties::setAdmixturesDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcMechanicalConcreteMaterialProperties::hasWorkability() const { return !entity->getArgument(9)->isNull(); } -std::string IfcMechanicalConcreteMaterialProperties::Workability() const { return *entity->getArgument(9); } -void IfcMechanicalConcreteMaterialProperties::setWorkability(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcMechanicalConcreteMaterialProperties::hasProtectivePoreRatio() const { return !entity->getArgument(10)->isNull(); } -double IfcMechanicalConcreteMaterialProperties::ProtectivePoreRatio() const { return *entity->getArgument(10); } -void IfcMechanicalConcreteMaterialProperties::setProtectivePoreRatio(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcMechanicalConcreteMaterialProperties::hasWaterImpermeability() const { return !entity->getArgument(11)->isNull(); } -std::string IfcMechanicalConcreteMaterialProperties::WaterImpermeability() const { return *entity->getArgument(11); } -void IfcMechanicalConcreteMaterialProperties::setWaterImpermeability(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcMechanicalConcreteMaterialProperties::is(Type::Enum v) const { return v == Type::IfcMechanicalConcreteMaterialProperties || IfcMechanicalMaterialProperties::is(v); } -Type::Enum IfcMechanicalConcreteMaterialProperties::type() const { return Type::IfcMechanicalConcreteMaterialProperties; } +bool IfcMechanicalConcreteMaterialProperties::hasCompressiveStrength() const { return !data_->getArgument(6)->isNull(); } +double IfcMechanicalConcreteMaterialProperties::CompressiveStrength() const { return *data_->getArgument(6); } +void IfcMechanicalConcreteMaterialProperties::setCompressiveStrength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcMechanicalConcreteMaterialProperties::hasMaxAggregateSize() const { return !data_->getArgument(7)->isNull(); } +double IfcMechanicalConcreteMaterialProperties::MaxAggregateSize() const { return *data_->getArgument(7); } +void IfcMechanicalConcreteMaterialProperties::setMaxAggregateSize(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcMechanicalConcreteMaterialProperties::hasAdmixturesDescription() const { return !data_->getArgument(8)->isNull(); } +std::string IfcMechanicalConcreteMaterialProperties::AdmixturesDescription() const { return *data_->getArgument(8); } +void IfcMechanicalConcreteMaterialProperties::setAdmixturesDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcMechanicalConcreteMaterialProperties::hasWorkability() const { return !data_->getArgument(9)->isNull(); } +std::string IfcMechanicalConcreteMaterialProperties::Workability() const { return *data_->getArgument(9); } +void IfcMechanicalConcreteMaterialProperties::setWorkability(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcMechanicalConcreteMaterialProperties::hasProtectivePoreRatio() const { return !data_->getArgument(10)->isNull(); } +double IfcMechanicalConcreteMaterialProperties::ProtectivePoreRatio() const { return *data_->getArgument(10); } +void IfcMechanicalConcreteMaterialProperties::setProtectivePoreRatio(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcMechanicalConcreteMaterialProperties::hasWaterImpermeability() const { return !data_->getArgument(11)->isNull(); } +std::string IfcMechanicalConcreteMaterialProperties::WaterImpermeability() const { return *data_->getArgument(11); } +void IfcMechanicalConcreteMaterialProperties::setWaterImpermeability(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } + + +const IfcParse::entity& IfcMechanicalConcreteMaterialProperties::declaration() const { return *IfcMechanicalConcreteMaterialProperties_type; } Type::Enum IfcMechanicalConcreteMaterialProperties::Class() { return Type::IfcMechanicalConcreteMaterialProperties; } -IfcMechanicalConcreteMaterialProperties::IfcMechanicalConcreteMaterialProperties(IfcAbstractEntity* e) : IfcMechanicalMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMechanicalConcreteMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMechanicalConcreteMaterialProperties::IfcMechanicalConcreteMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient, boost::optional< double > v7_CompressiveStrength, boost::optional< double > v8_MaxAggregateSize, boost::optional< std::string > v9_AdmixturesDescription, boost::optional< std::string > v10_Workability, boost::optional< double > v11_ProtectivePoreRatio, boost::optional< std::string > v12_WaterImpermeability) : IfcMechanicalMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_DynamicViscosity) { e->setArgument(1,(*v2_DynamicViscosity)); } else { e->setArgument(1); } if (v3_YoungModulus) { e->setArgument(2,(*v3_YoungModulus)); } else { e->setArgument(2); } if (v4_ShearModulus) { e->setArgument(3,(*v4_ShearModulus)); } else { e->setArgument(3); } if (v5_PoissonRatio) { e->setArgument(4,(*v5_PoissonRatio)); } else { e->setArgument(4); } if (v6_ThermalExpansionCoefficient) { e->setArgument(5,(*v6_ThermalExpansionCoefficient)); } else { e->setArgument(5); } if (v7_CompressiveStrength) { e->setArgument(6,(*v7_CompressiveStrength)); } else { e->setArgument(6); } if (v8_MaxAggregateSize) { e->setArgument(7,(*v8_MaxAggregateSize)); } else { e->setArgument(7); } if (v9_AdmixturesDescription) { e->setArgument(8,(*v9_AdmixturesDescription)); } else { e->setArgument(8); } if (v10_Workability) { e->setArgument(9,(*v10_Workability)); } else { e->setArgument(9); } if (v11_ProtectivePoreRatio) { e->setArgument(10,(*v11_ProtectivePoreRatio)); } else { e->setArgument(10); } if (v12_WaterImpermeability) { e->setArgument(11,(*v12_WaterImpermeability)); } else { e->setArgument(11); } entity = e; EntityBuffer::Add(this); } +IfcMechanicalConcreteMaterialProperties::IfcMechanicalConcreteMaterialProperties(IfcAbstractEntity* e) : IfcMechanicalMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMechanicalConcreteMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMechanicalConcreteMaterialProperties::IfcMechanicalConcreteMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient, boost::optional< double > v7_CompressiveStrength, boost::optional< double > v8_MaxAggregateSize, boost::optional< std::string > v9_AdmixturesDescription, boost::optional< std::string > v10_Workability, boost::optional< double > v11_ProtectivePoreRatio, boost::optional< std::string > v12_WaterImpermeability) : IfcMechanicalMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_DynamicViscosity) { e->setArgument(1,(*v2_DynamicViscosity)); } else { e->setArgument(1); } if (v3_YoungModulus) { e->setArgument(2,(*v3_YoungModulus)); } else { e->setArgument(2); } if (v4_ShearModulus) { e->setArgument(3,(*v4_ShearModulus)); } else { e->setArgument(3); } if (v5_PoissonRatio) { e->setArgument(4,(*v5_PoissonRatio)); } else { e->setArgument(4); } if (v6_ThermalExpansionCoefficient) { e->setArgument(5,(*v6_ThermalExpansionCoefficient)); } else { e->setArgument(5); } if (v7_CompressiveStrength) { e->setArgument(6,(*v7_CompressiveStrength)); } else { e->setArgument(6); } if (v8_MaxAggregateSize) { e->setArgument(7,(*v8_MaxAggregateSize)); } else { e->setArgument(7); } if (v9_AdmixturesDescription) { e->setArgument(8,(*v9_AdmixturesDescription)); } else { e->setArgument(8); } if (v10_Workability) { e->setArgument(9,(*v10_Workability)); } else { e->setArgument(9); } if (v11_ProtectivePoreRatio) { e->setArgument(10,(*v11_ProtectivePoreRatio)); } else { e->setArgument(10); } if (v12_WaterImpermeability) { e->setArgument(11,(*v12_WaterImpermeability)); } else { e->setArgument(11); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMechanicalFastener -bool IfcMechanicalFastener::hasNominalDiameter() const { return !entity->getArgument(8)->isNull(); } -double IfcMechanicalFastener::NominalDiameter() const { return *entity->getArgument(8); } -void IfcMechanicalFastener::setNominalDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcMechanicalFastener::hasNominalLength() const { return !entity->getArgument(9)->isNull(); } -double IfcMechanicalFastener::NominalLength() const { return *entity->getArgument(9); } -void IfcMechanicalFastener::setNominalLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcMechanicalFastener::is(Type::Enum v) const { return v == Type::IfcMechanicalFastener || IfcFastener::is(v); } -Type::Enum IfcMechanicalFastener::type() const { return Type::IfcMechanicalFastener; } +bool IfcMechanicalFastener::hasNominalDiameter() const { return !data_->getArgument(8)->isNull(); } +double IfcMechanicalFastener::NominalDiameter() const { return *data_->getArgument(8); } +void IfcMechanicalFastener::setNominalDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcMechanicalFastener::hasNominalLength() const { return !data_->getArgument(9)->isNull(); } +double IfcMechanicalFastener::NominalLength() const { return *data_->getArgument(9); } +void IfcMechanicalFastener::setNominalLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcMechanicalFastener::declaration() const { return *IfcMechanicalFastener_type; } Type::Enum IfcMechanicalFastener::Class() { return Type::IfcMechanicalFastener; } -IfcMechanicalFastener::IfcMechanicalFastener(IfcAbstractEntity* e) : IfcFastener((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMechanicalFastener)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMechanicalFastener::IfcMechanicalFastener(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_NominalDiameter, boost::optional< double > v10_NominalLength) : IfcFastener((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_NominalDiameter) { e->setArgument(8,(*v9_NominalDiameter)); } else { e->setArgument(8); } if (v10_NominalLength) { e->setArgument(9,(*v10_NominalLength)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcMechanicalFastener::IfcMechanicalFastener(IfcAbstractEntity* e) : IfcFastener((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMechanicalFastener)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMechanicalFastener::IfcMechanicalFastener(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_NominalDiameter, boost::optional< double > v10_NominalLength) : IfcFastener((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_NominalDiameter) { e->setArgument(8,(*v9_NominalDiameter)); } else { e->setArgument(8); } if (v10_NominalLength) { e->setArgument(9,(*v10_NominalLength)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMechanicalFastenerType -bool IfcMechanicalFastenerType::is(Type::Enum v) const { return v == Type::IfcMechanicalFastenerType || IfcFastenerType::is(v); } -Type::Enum IfcMechanicalFastenerType::type() const { return Type::IfcMechanicalFastenerType; } + + +const IfcParse::entity& IfcMechanicalFastenerType::declaration() const { return *IfcMechanicalFastenerType_type; } Type::Enum IfcMechanicalFastenerType::Class() { return Type::IfcMechanicalFastenerType; } -IfcMechanicalFastenerType::IfcMechanicalFastenerType(IfcAbstractEntity* e) : IfcFastenerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMechanicalFastenerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMechanicalFastenerType::IfcMechanicalFastenerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcFastenerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcMechanicalFastenerType::IfcMechanicalFastenerType(IfcAbstractEntity* e) : IfcFastenerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMechanicalFastenerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMechanicalFastenerType::IfcMechanicalFastenerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcFastenerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMechanicalMaterialProperties -bool IfcMechanicalMaterialProperties::hasDynamicViscosity() const { return !entity->getArgument(1)->isNull(); } -double IfcMechanicalMaterialProperties::DynamicViscosity() const { return *entity->getArgument(1); } -void IfcMechanicalMaterialProperties::setDynamicViscosity(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcMechanicalMaterialProperties::hasYoungModulus() const { return !entity->getArgument(2)->isNull(); } -double IfcMechanicalMaterialProperties::YoungModulus() const { return *entity->getArgument(2); } -void IfcMechanicalMaterialProperties::setYoungModulus(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcMechanicalMaterialProperties::hasShearModulus() const { return !entity->getArgument(3)->isNull(); } -double IfcMechanicalMaterialProperties::ShearModulus() const { return *entity->getArgument(3); } -void IfcMechanicalMaterialProperties::setShearModulus(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcMechanicalMaterialProperties::hasPoissonRatio() const { return !entity->getArgument(4)->isNull(); } -double IfcMechanicalMaterialProperties::PoissonRatio() const { return *entity->getArgument(4); } -void IfcMechanicalMaterialProperties::setPoissonRatio(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcMechanicalMaterialProperties::hasThermalExpansionCoefficient() const { return !entity->getArgument(5)->isNull(); } -double IfcMechanicalMaterialProperties::ThermalExpansionCoefficient() const { return *entity->getArgument(5); } -void IfcMechanicalMaterialProperties::setThermalExpansionCoefficient(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcMechanicalMaterialProperties::is(Type::Enum v) const { return v == Type::IfcMechanicalMaterialProperties || IfcMaterialProperties::is(v); } -Type::Enum IfcMechanicalMaterialProperties::type() const { return Type::IfcMechanicalMaterialProperties; } +bool IfcMechanicalMaterialProperties::hasDynamicViscosity() const { return !data_->getArgument(1)->isNull(); } +double IfcMechanicalMaterialProperties::DynamicViscosity() const { return *data_->getArgument(1); } +void IfcMechanicalMaterialProperties::setDynamicViscosity(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcMechanicalMaterialProperties::hasYoungModulus() const { return !data_->getArgument(2)->isNull(); } +double IfcMechanicalMaterialProperties::YoungModulus() const { return *data_->getArgument(2); } +void IfcMechanicalMaterialProperties::setYoungModulus(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcMechanicalMaterialProperties::hasShearModulus() const { return !data_->getArgument(3)->isNull(); } +double IfcMechanicalMaterialProperties::ShearModulus() const { return *data_->getArgument(3); } +void IfcMechanicalMaterialProperties::setShearModulus(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcMechanicalMaterialProperties::hasPoissonRatio() const { return !data_->getArgument(4)->isNull(); } +double IfcMechanicalMaterialProperties::PoissonRatio() const { return *data_->getArgument(4); } +void IfcMechanicalMaterialProperties::setPoissonRatio(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcMechanicalMaterialProperties::hasThermalExpansionCoefficient() const { return !data_->getArgument(5)->isNull(); } +double IfcMechanicalMaterialProperties::ThermalExpansionCoefficient() const { return *data_->getArgument(5); } +void IfcMechanicalMaterialProperties::setThermalExpansionCoefficient(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcMechanicalMaterialProperties::declaration() const { return *IfcMechanicalMaterialProperties_type; } Type::Enum IfcMechanicalMaterialProperties::Class() { return Type::IfcMechanicalMaterialProperties; } -IfcMechanicalMaterialProperties::IfcMechanicalMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMechanicalMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMechanicalMaterialProperties::IfcMechanicalMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_DynamicViscosity) { e->setArgument(1,(*v2_DynamicViscosity)); } else { e->setArgument(1); } if (v3_YoungModulus) { e->setArgument(2,(*v3_YoungModulus)); } else { e->setArgument(2); } if (v4_ShearModulus) { e->setArgument(3,(*v4_ShearModulus)); } else { e->setArgument(3); } if (v5_PoissonRatio) { e->setArgument(4,(*v5_PoissonRatio)); } else { e->setArgument(4); } if (v6_ThermalExpansionCoefficient) { e->setArgument(5,(*v6_ThermalExpansionCoefficient)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcMechanicalMaterialProperties::IfcMechanicalMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMechanicalMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMechanicalMaterialProperties::IfcMechanicalMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_DynamicViscosity) { e->setArgument(1,(*v2_DynamicViscosity)); } else { e->setArgument(1); } if (v3_YoungModulus) { e->setArgument(2,(*v3_YoungModulus)); } else { e->setArgument(2); } if (v4_ShearModulus) { e->setArgument(3,(*v4_ShearModulus)); } else { e->setArgument(3); } if (v5_PoissonRatio) { e->setArgument(4,(*v5_PoissonRatio)); } else { e->setArgument(4); } if (v6_ThermalExpansionCoefficient) { e->setArgument(5,(*v6_ThermalExpansionCoefficient)); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMechanicalSteelMaterialProperties -bool IfcMechanicalSteelMaterialProperties::hasYieldStress() const { return !entity->getArgument(6)->isNull(); } -double IfcMechanicalSteelMaterialProperties::YieldStress() const { return *entity->getArgument(6); } -void IfcMechanicalSteelMaterialProperties::setYieldStress(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcMechanicalSteelMaterialProperties::hasUltimateStress() const { return !entity->getArgument(7)->isNull(); } -double IfcMechanicalSteelMaterialProperties::UltimateStress() const { return *entity->getArgument(7); } -void IfcMechanicalSteelMaterialProperties::setUltimateStress(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcMechanicalSteelMaterialProperties::hasUltimateStrain() const { return !entity->getArgument(8)->isNull(); } -double IfcMechanicalSteelMaterialProperties::UltimateStrain() const { return *entity->getArgument(8); } -void IfcMechanicalSteelMaterialProperties::setUltimateStrain(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcMechanicalSteelMaterialProperties::hasHardeningModule() const { return !entity->getArgument(9)->isNull(); } -double IfcMechanicalSteelMaterialProperties::HardeningModule() const { return *entity->getArgument(9); } -void IfcMechanicalSteelMaterialProperties::setHardeningModule(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcMechanicalSteelMaterialProperties::hasProportionalStress() const { return !entity->getArgument(10)->isNull(); } -double IfcMechanicalSteelMaterialProperties::ProportionalStress() const { return *entity->getArgument(10); } -void IfcMechanicalSteelMaterialProperties::setProportionalStress(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcMechanicalSteelMaterialProperties::hasPlasticStrain() const { return !entity->getArgument(11)->isNull(); } -double IfcMechanicalSteelMaterialProperties::PlasticStrain() const { return *entity->getArgument(11); } -void IfcMechanicalSteelMaterialProperties::setPlasticStrain(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcMechanicalSteelMaterialProperties::hasRelaxations() const { return !entity->getArgument(12)->isNull(); } -IfcTemplatedEntityList< IfcRelaxation >::ptr IfcMechanicalSteelMaterialProperties::Relaxations() const { IfcEntityList::ptr es = *entity->getArgument(12); return es->as(); } -void IfcMechanicalSteelMaterialProperties::setRelaxations(IfcTemplatedEntityList< IfcRelaxation >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v->generalize()); } -bool IfcMechanicalSteelMaterialProperties::is(Type::Enum v) const { return v == Type::IfcMechanicalSteelMaterialProperties || IfcMechanicalMaterialProperties::is(v); } -Type::Enum IfcMechanicalSteelMaterialProperties::type() const { return Type::IfcMechanicalSteelMaterialProperties; } +bool IfcMechanicalSteelMaterialProperties::hasYieldStress() const { return !data_->getArgument(6)->isNull(); } +double IfcMechanicalSteelMaterialProperties::YieldStress() const { return *data_->getArgument(6); } +void IfcMechanicalSteelMaterialProperties::setYieldStress(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcMechanicalSteelMaterialProperties::hasUltimateStress() const { return !data_->getArgument(7)->isNull(); } +double IfcMechanicalSteelMaterialProperties::UltimateStress() const { return *data_->getArgument(7); } +void IfcMechanicalSteelMaterialProperties::setUltimateStress(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcMechanicalSteelMaterialProperties::hasUltimateStrain() const { return !data_->getArgument(8)->isNull(); } +double IfcMechanicalSteelMaterialProperties::UltimateStrain() const { return *data_->getArgument(8); } +void IfcMechanicalSteelMaterialProperties::setUltimateStrain(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcMechanicalSteelMaterialProperties::hasHardeningModule() const { return !data_->getArgument(9)->isNull(); } +double IfcMechanicalSteelMaterialProperties::HardeningModule() const { return *data_->getArgument(9); } +void IfcMechanicalSteelMaterialProperties::setHardeningModule(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcMechanicalSteelMaterialProperties::hasProportionalStress() const { return !data_->getArgument(10)->isNull(); } +double IfcMechanicalSteelMaterialProperties::ProportionalStress() const { return *data_->getArgument(10); } +void IfcMechanicalSteelMaterialProperties::setProportionalStress(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcMechanicalSteelMaterialProperties::hasPlasticStrain() const { return !data_->getArgument(11)->isNull(); } +double IfcMechanicalSteelMaterialProperties::PlasticStrain() const { return *data_->getArgument(11); } +void IfcMechanicalSteelMaterialProperties::setPlasticStrain(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcMechanicalSteelMaterialProperties::hasRelaxations() const { return !data_->getArgument(12)->isNull(); } +IfcTemplatedEntityList< IfcRelaxation >::ptr IfcMechanicalSteelMaterialProperties::Relaxations() const { IfcEntityList::ptr es = *data_->getArgument(12); return es->as(); } +void IfcMechanicalSteelMaterialProperties::setRelaxations(IfcTemplatedEntityList< IfcRelaxation >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v->generalize()); } + + +const IfcParse::entity& IfcMechanicalSteelMaterialProperties::declaration() const { return *IfcMechanicalSteelMaterialProperties_type; } Type::Enum IfcMechanicalSteelMaterialProperties::Class() { return Type::IfcMechanicalSteelMaterialProperties; } -IfcMechanicalSteelMaterialProperties::IfcMechanicalSteelMaterialProperties(IfcAbstractEntity* e) : IfcMechanicalMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMechanicalSteelMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMechanicalSteelMaterialProperties::IfcMechanicalSteelMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient, boost::optional< double > v7_YieldStress, boost::optional< double > v8_UltimateStress, boost::optional< double > v9_UltimateStrain, boost::optional< double > v10_HardeningModule, boost::optional< double > v11_ProportionalStress, boost::optional< double > v12_PlasticStrain, boost::optional< IfcTemplatedEntityList< IfcRelaxation >::ptr > v13_Relaxations) : IfcMechanicalMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_DynamicViscosity) { e->setArgument(1,(*v2_DynamicViscosity)); } else { e->setArgument(1); } if (v3_YoungModulus) { e->setArgument(2,(*v3_YoungModulus)); } else { e->setArgument(2); } if (v4_ShearModulus) { e->setArgument(3,(*v4_ShearModulus)); } else { e->setArgument(3); } if (v5_PoissonRatio) { e->setArgument(4,(*v5_PoissonRatio)); } else { e->setArgument(4); } if (v6_ThermalExpansionCoefficient) { e->setArgument(5,(*v6_ThermalExpansionCoefficient)); } else { e->setArgument(5); } if (v7_YieldStress) { e->setArgument(6,(*v7_YieldStress)); } else { e->setArgument(6); } if (v8_UltimateStress) { e->setArgument(7,(*v8_UltimateStress)); } else { e->setArgument(7); } if (v9_UltimateStrain) { e->setArgument(8,(*v9_UltimateStrain)); } else { e->setArgument(8); } if (v10_HardeningModule) { e->setArgument(9,(*v10_HardeningModule)); } else { e->setArgument(9); } if (v11_ProportionalStress) { e->setArgument(10,(*v11_ProportionalStress)); } else { e->setArgument(10); } if (v12_PlasticStrain) { e->setArgument(11,(*v12_PlasticStrain)); } else { e->setArgument(11); } if (v13_Relaxations) { e->setArgument(12,(*v13_Relaxations)->generalize()); } else { e->setArgument(12); } entity = e; EntityBuffer::Add(this); } +IfcMechanicalSteelMaterialProperties::IfcMechanicalSteelMaterialProperties(IfcAbstractEntity* e) : IfcMechanicalMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMechanicalSteelMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMechanicalSteelMaterialProperties::IfcMechanicalSteelMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient, boost::optional< double > v7_YieldStress, boost::optional< double > v8_UltimateStress, boost::optional< double > v9_UltimateStrain, boost::optional< double > v10_HardeningModule, boost::optional< double > v11_ProportionalStress, boost::optional< double > v12_PlasticStrain, boost::optional< IfcTemplatedEntityList< IfcRelaxation >::ptr > v13_Relaxations) : IfcMechanicalMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_DynamicViscosity) { e->setArgument(1,(*v2_DynamicViscosity)); } else { e->setArgument(1); } if (v3_YoungModulus) { e->setArgument(2,(*v3_YoungModulus)); } else { e->setArgument(2); } if (v4_ShearModulus) { e->setArgument(3,(*v4_ShearModulus)); } else { e->setArgument(3); } if (v5_PoissonRatio) { e->setArgument(4,(*v5_PoissonRatio)); } else { e->setArgument(4); } if (v6_ThermalExpansionCoefficient) { e->setArgument(5,(*v6_ThermalExpansionCoefficient)); } else { e->setArgument(5); } if (v7_YieldStress) { e->setArgument(6,(*v7_YieldStress)); } else { e->setArgument(6); } if (v8_UltimateStress) { e->setArgument(7,(*v8_UltimateStress)); } else { e->setArgument(7); } if (v9_UltimateStrain) { e->setArgument(8,(*v9_UltimateStrain)); } else { e->setArgument(8); } if (v10_HardeningModule) { e->setArgument(9,(*v10_HardeningModule)); } else { e->setArgument(9); } if (v11_ProportionalStress) { e->setArgument(10,(*v11_ProportionalStress)); } else { e->setArgument(10); } if (v12_PlasticStrain) { e->setArgument(11,(*v12_PlasticStrain)); } else { e->setArgument(11); } if (v13_Relaxations) { e->setArgument(12,(*v13_Relaxations)->generalize()); } else { e->setArgument(12); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMember -bool IfcMember::is(Type::Enum v) const { return v == Type::IfcMember || IfcBuildingElement::is(v); } -Type::Enum IfcMember::type() const { return Type::IfcMember; } + + +const IfcParse::entity& IfcMember::declaration() const { return *IfcMember_type; } Type::Enum IfcMember::Class() { return Type::IfcMember; } -IfcMember::IfcMember(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMember)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMember::IfcMember(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcMember::IfcMember(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMember)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMember::IfcMember(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMemberType -IfcMemberTypeEnum::IfcMemberTypeEnum IfcMemberType::PredefinedType() const { return IfcMemberTypeEnum::FromString(*entity->getArgument(9)); } -void IfcMemberType::setPredefinedType(IfcMemberTypeEnum::IfcMemberTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcMemberTypeEnum::ToString(v)); } -bool IfcMemberType::is(Type::Enum v) const { return v == Type::IfcMemberType || IfcBuildingElementType::is(v); } -Type::Enum IfcMemberType::type() const { return Type::IfcMemberType; } +IfcMemberTypeEnum::IfcMemberTypeEnum IfcMemberType::PredefinedType() const { return IfcMemberTypeEnum::FromString(*data_->getArgument(9)); } +void IfcMemberType::setPredefinedType(IfcMemberTypeEnum::IfcMemberTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcMemberTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcMemberType::declaration() const { return *IfcMemberType_type; } Type::Enum IfcMemberType::Class() { return Type::IfcMemberType; } -IfcMemberType::IfcMemberType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMemberType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMemberType::IfcMemberType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcMemberTypeEnum::IfcMemberTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcMemberTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcMemberType::IfcMemberType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMemberType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMemberType::IfcMemberType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcMemberTypeEnum::IfcMemberTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcMemberTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMetric -IfcBenchmarkEnum::IfcBenchmarkEnum IfcMetric::Benchmark() const { return IfcBenchmarkEnum::FromString(*entity->getArgument(7)); } -void IfcMetric::setBenchmark(IfcBenchmarkEnum::IfcBenchmarkEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcBenchmarkEnum::ToString(v)); } -bool IfcMetric::hasValueSource() const { return !entity->getArgument(8)->isNull(); } -std::string IfcMetric::ValueSource() const { return *entity->getArgument(8); } -void IfcMetric::setValueSource(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -IfcMetricValueSelect* IfcMetric::DataValue() const { return (IfcMetricValueSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcMetric::setDataValue(IfcMetricValueSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcMetric::is(Type::Enum v) const { return v == Type::IfcMetric || IfcConstraint::is(v); } -Type::Enum IfcMetric::type() const { return Type::IfcMetric; } +IfcBenchmarkEnum::IfcBenchmarkEnum IfcMetric::Benchmark() const { return IfcBenchmarkEnum::FromString(*data_->getArgument(7)); } +void IfcMetric::setBenchmark(IfcBenchmarkEnum::IfcBenchmarkEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcBenchmarkEnum::ToString(v)); } +bool IfcMetric::hasValueSource() const { return !data_->getArgument(8)->isNull(); } +std::string IfcMetric::ValueSource() const { return *data_->getArgument(8); } +void IfcMetric::setValueSource(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +IfcMetricValueSelect* IfcMetric::DataValue() const { return (IfcMetricValueSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcMetric::setDataValue(IfcMetricValueSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcMetric::declaration() const { return *IfcMetric_type; } Type::Enum IfcMetric::Class() { return Type::IfcMetric; } -IfcMetric::IfcMetric(IfcAbstractEntity* e) : IfcConstraint((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMetric)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMetric::IfcMetric(std::string v1_Name, boost::optional< std::string > v2_Description, IfcConstraintEnum::IfcConstraintEnum v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, IfcActorSelect* v5_CreatingActor, IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, IfcBenchmarkEnum::IfcBenchmarkEnum v8_Benchmark, boost::optional< std::string > v9_ValueSource, IfcMetricValueSelect* v10_DataValue) : IfcConstraint((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,v3_ConstraintGrade,IfcConstraintEnum::ToString(v3_ConstraintGrade)); if (v4_ConstraintSource) { e->setArgument(3,(*v4_ConstraintSource)); } else { e->setArgument(3); } e->setArgument(4,(v5_CreatingActor)); e->setArgument(5,(v6_CreationTime)); if (v7_UserDefinedGrade) { e->setArgument(6,(*v7_UserDefinedGrade)); } else { e->setArgument(6); } e->setArgument(7,v8_Benchmark,IfcBenchmarkEnum::ToString(v8_Benchmark)); if (v9_ValueSource) { e->setArgument(8,(*v9_ValueSource)); } else { e->setArgument(8); } e->setArgument(9,(v10_DataValue)); entity = e; EntityBuffer::Add(this); } +IfcMetric::IfcMetric(IfcAbstractEntity* e) : IfcConstraint((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMetric)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMetric::IfcMetric(std::string v1_Name, boost::optional< std::string > v2_Description, IfcConstraintEnum::IfcConstraintEnum v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, IfcActorSelect* v5_CreatingActor, IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, IfcBenchmarkEnum::IfcBenchmarkEnum v8_Benchmark, boost::optional< std::string > v9_ValueSource, IfcMetricValueSelect* v10_DataValue) : IfcConstraint((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,v3_ConstraintGrade,IfcConstraintEnum::ToString(v3_ConstraintGrade)); if (v4_ConstraintSource) { e->setArgument(3,(*v4_ConstraintSource)); } else { e->setArgument(3); } e->setArgument(4,(v5_CreatingActor)); e->setArgument(5,(v6_CreationTime)); if (v7_UserDefinedGrade) { e->setArgument(6,(*v7_UserDefinedGrade)); } else { e->setArgument(6); } e->setArgument(7,v8_Benchmark,IfcBenchmarkEnum::ToString(v8_Benchmark)); if (v9_ValueSource) { e->setArgument(8,(*v9_ValueSource)); } else { e->setArgument(8); } e->setArgument(9,(v10_DataValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMonetaryUnit -IfcCurrencyEnum::IfcCurrencyEnum IfcMonetaryUnit::Currency() const { return IfcCurrencyEnum::FromString(*entity->getArgument(0)); } -void IfcMonetaryUnit::setCurrency(IfcCurrencyEnum::IfcCurrencyEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v,IfcCurrencyEnum::ToString(v)); } -bool IfcMonetaryUnit::is(Type::Enum v) const { return v == Type::IfcMonetaryUnit; } -Type::Enum IfcMonetaryUnit::type() const { return Type::IfcMonetaryUnit; } +IfcCurrencyEnum::IfcCurrencyEnum IfcMonetaryUnit::Currency() const { return IfcCurrencyEnum::FromString(*data_->getArgument(0)); } +void IfcMonetaryUnit::setCurrency(IfcCurrencyEnum::IfcCurrencyEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v,IfcCurrencyEnum::ToString(v)); } + + +const IfcParse::entity& IfcMonetaryUnit::declaration() const { return *IfcMonetaryUnit_type; } Type::Enum IfcMonetaryUnit::Class() { return Type::IfcMonetaryUnit; } -IfcMonetaryUnit::IfcMonetaryUnit(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMonetaryUnit)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMonetaryUnit::IfcMonetaryUnit(IfcCurrencyEnum::IfcCurrencyEnum v1_Currency) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_Currency,IfcCurrencyEnum::ToString(v1_Currency)); entity = e; EntityBuffer::Add(this); } +IfcMonetaryUnit::IfcMonetaryUnit(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMonetaryUnit)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMonetaryUnit::IfcMonetaryUnit(IfcCurrencyEnum::IfcCurrencyEnum v1_Currency) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_Currency,IfcCurrencyEnum::ToString(v1_Currency)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMotorConnectionType -IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum IfcMotorConnectionType::PredefinedType() const { return IfcMotorConnectionTypeEnum::FromString(*entity->getArgument(9)); } -void IfcMotorConnectionType::setPredefinedType(IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcMotorConnectionTypeEnum::ToString(v)); } -bool IfcMotorConnectionType::is(Type::Enum v) const { return v == Type::IfcMotorConnectionType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcMotorConnectionType::type() const { return Type::IfcMotorConnectionType; } +IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum IfcMotorConnectionType::PredefinedType() const { return IfcMotorConnectionTypeEnum::FromString(*data_->getArgument(9)); } +void IfcMotorConnectionType::setPredefinedType(IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcMotorConnectionTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcMotorConnectionType::declaration() const { return *IfcMotorConnectionType_type; } Type::Enum IfcMotorConnectionType::Class() { return Type::IfcMotorConnectionType; } -IfcMotorConnectionType::IfcMotorConnectionType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMotorConnectionType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMotorConnectionType::IfcMotorConnectionType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcMotorConnectionTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcMotorConnectionType::IfcMotorConnectionType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMotorConnectionType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMotorConnectionType::IfcMotorConnectionType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcMotorConnectionTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMove -IfcSpatialStructureElement* IfcMove::MoveFrom() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcMove::setMoveFrom(IfcSpatialStructureElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -IfcSpatialStructureElement* IfcMove::MoveTo() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(11))); } -void IfcMove::setMoveTo(IfcSpatialStructureElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcMove::hasPunchList() const { return !entity->getArgument(12)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcMove::PunchList() const { return *entity->getArgument(12); } -void IfcMove::setPunchList(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcMove::is(Type::Enum v) const { return v == Type::IfcMove || IfcTask::is(v); } -Type::Enum IfcMove::type() const { return Type::IfcMove; } +IfcSpatialStructureElement* IfcMove::MoveFrom() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcMove::setMoveFrom(IfcSpatialStructureElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +IfcSpatialStructureElement* IfcMove::MoveTo() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(11))); } +void IfcMove::setMoveTo(IfcSpatialStructureElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcMove::hasPunchList() const { return !data_->getArgument(12)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcMove::PunchList() const { return *data_->getArgument(12); } +void IfcMove::setPunchList(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } + + +const IfcParse::entity& IfcMove::declaration() const { return *IfcMove_type; } Type::Enum IfcMove::Class() { return Type::IfcMove; } -IfcMove::IfcMove(IfcAbstractEntity* e) : IfcTask((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMove)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMove::IfcMove(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority, IfcSpatialStructureElement* v11_MoveFrom, IfcSpatialStructureElement* v12_MoveTo, boost::optional< std::vector< std::string > /*[1:?]*/ > v13_PunchList) : IfcTask((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_TaskId)); if (v7_Status) { e->setArgument(6,(*v7_Status)); } else { e->setArgument(6); } if (v8_WorkMethod) { e->setArgument(7,(*v8_WorkMethod)); } else { e->setArgument(7); } e->setArgument(8,(v9_IsMilestone)); if (v10_Priority) { e->setArgument(9,(*v10_Priority)); } else { e->setArgument(9); } e->setArgument(10,(v11_MoveFrom)); e->setArgument(11,(v12_MoveTo)); if (v13_PunchList) { e->setArgument(12,(*v13_PunchList)); } else { e->setArgument(12); } entity = e; EntityBuffer::Add(this); } +IfcMove::IfcMove(IfcAbstractEntity* e) : IfcTask((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMove)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMove::IfcMove(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority, IfcSpatialStructureElement* v11_MoveFrom, IfcSpatialStructureElement* v12_MoveTo, boost::optional< std::vector< std::string > /*[1:?]*/ > v13_PunchList) : IfcTask((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_TaskId)); if (v7_Status) { e->setArgument(6,(*v7_Status)); } else { e->setArgument(6); } if (v8_WorkMethod) { e->setArgument(7,(*v8_WorkMethod)); } else { e->setArgument(7); } e->setArgument(8,(v9_IsMilestone)); if (v10_Priority) { e->setArgument(9,(*v10_Priority)); } else { e->setArgument(9); } e->setArgument(10,(v11_MoveFrom)); e->setArgument(11,(v12_MoveTo)); if (v13_PunchList) { e->setArgument(12,(*v13_PunchList)); } else { e->setArgument(12); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcNamedUnit -IfcDimensionalExponents* IfcNamedUnit::Dimensions() const { return (IfcDimensionalExponents*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcNamedUnit::setDimensions(IfcDimensionalExponents* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcUnitEnum::IfcUnitEnum IfcNamedUnit::UnitType() const { return IfcUnitEnum::FromString(*entity->getArgument(1)); } -void IfcNamedUnit::setUnitType(IfcUnitEnum::IfcUnitEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v,IfcUnitEnum::ToString(v)); } -bool IfcNamedUnit::is(Type::Enum v) const { return v == Type::IfcNamedUnit; } -Type::Enum IfcNamedUnit::type() const { return Type::IfcNamedUnit; } +IfcDimensionalExponents* IfcNamedUnit::Dimensions() const { return (IfcDimensionalExponents*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcNamedUnit::setDimensions(IfcDimensionalExponents* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcUnitEnum::IfcUnitEnum IfcNamedUnit::UnitType() const { return IfcUnitEnum::FromString(*data_->getArgument(1)); } +void IfcNamedUnit::setUnitType(IfcUnitEnum::IfcUnitEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v,IfcUnitEnum::ToString(v)); } + + +const IfcParse::entity& IfcNamedUnit::declaration() const { return *IfcNamedUnit_type; } Type::Enum IfcNamedUnit::Class() { return Type::IfcNamedUnit; } -IfcNamedUnit::IfcNamedUnit(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcNamedUnit)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcNamedUnit::IfcNamedUnit(IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Dimensions)); e->setArgument(1,v2_UnitType,IfcUnitEnum::ToString(v2_UnitType)); entity = e; EntityBuffer::Add(this); } +IfcNamedUnit::IfcNamedUnit(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcNamedUnit)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcNamedUnit::IfcNamedUnit(IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Dimensions)); e->setArgument(1,v2_UnitType,IfcUnitEnum::ToString(v2_UnitType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcObject -bool IfcObject::hasObjectType() const { return !entity->getArgument(4)->isNull(); } -std::string IfcObject::ObjectType() const { return *entity->getArgument(4); } -void IfcObject::setObjectType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcRelDefines::list::ptr IfcObject::IsDefinedBy() const { return entity->getInverse(Type::IfcRelDefines, 4)->as(); } -bool IfcObject::is(Type::Enum v) const { return v == Type::IfcObject || IfcObjectDefinition::is(v); } -Type::Enum IfcObject::type() const { return Type::IfcObject; } +bool IfcObject::hasObjectType() const { return !data_->getArgument(4)->isNull(); } +std::string IfcObject::ObjectType() const { return *data_->getArgument(4); } +void IfcObject::setObjectType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + +IfcRelDefines::list::ptr IfcObject::IsDefinedBy() const { return data_->getInverse(Type::IfcRelDefines, 4)->as(); } + +const IfcParse::entity& IfcObject::declaration() const { return *IfcObject_type; } Type::Enum IfcObject::Class() { return Type::IfcObject; } -IfcObject::IfcObject(IfcAbstractEntity* e) : IfcObjectDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcObject)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcObject::IfcObject(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObjectDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcObject::IfcObject(IfcAbstractEntity* e) : IfcObjectDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcObject)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcObject::IfcObject(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObjectDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcObjectDefinition -IfcRelAssigns::list::ptr IfcObjectDefinition::HasAssignments() const { return entity->getInverse(Type::IfcRelAssigns, 4)->as(); } -IfcRelDecomposes::list::ptr IfcObjectDefinition::IsDecomposedBy() const { return entity->getInverse(Type::IfcRelDecomposes, 4)->as(); } -IfcRelDecomposes::list::ptr IfcObjectDefinition::Decomposes() const { return entity->getInverse(Type::IfcRelDecomposes, 5)->as(); } -IfcRelAssociates::list::ptr IfcObjectDefinition::HasAssociations() const { return entity->getInverse(Type::IfcRelAssociates, 4)->as(); } -bool IfcObjectDefinition::is(Type::Enum v) const { return v == Type::IfcObjectDefinition || IfcRoot::is(v); } -Type::Enum IfcObjectDefinition::type() const { return Type::IfcObjectDefinition; } + +IfcRelAssigns::list::ptr IfcObjectDefinition::HasAssignments() const { return data_->getInverse(Type::IfcRelAssigns, 4)->as(); } +IfcRelDecomposes::list::ptr IfcObjectDefinition::IsDecomposedBy() const { return data_->getInverse(Type::IfcRelDecomposes, 4)->as(); } +IfcRelDecomposes::list::ptr IfcObjectDefinition::Decomposes() const { return data_->getInverse(Type::IfcRelDecomposes, 5)->as(); } +IfcRelAssociates::list::ptr IfcObjectDefinition::HasAssociations() const { return data_->getInverse(Type::IfcRelAssociates, 4)->as(); } + +const IfcParse::entity& IfcObjectDefinition::declaration() const { return *IfcObjectDefinition_type; } Type::Enum IfcObjectDefinition::Class() { return Type::IfcObjectDefinition; } -IfcObjectDefinition::IfcObjectDefinition(IfcAbstractEntity* e) : IfcRoot((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcObjectDefinition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcObjectDefinition::IfcObjectDefinition(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRoot((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcObjectDefinition::IfcObjectDefinition(IfcAbstractEntity* e) : IfcRoot((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcObjectDefinition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcObjectDefinition::IfcObjectDefinition(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRoot((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcObjectPlacement -IfcProduct::list::ptr IfcObjectPlacement::PlacesObject() const { return entity->getInverse(Type::IfcProduct, 5)->as(); } -IfcLocalPlacement::list::ptr IfcObjectPlacement::ReferencedByPlacements() const { return entity->getInverse(Type::IfcLocalPlacement, 0)->as(); } -bool IfcObjectPlacement::is(Type::Enum v) const { return v == Type::IfcObjectPlacement; } -Type::Enum IfcObjectPlacement::type() const { return Type::IfcObjectPlacement; } + +IfcProduct::list::ptr IfcObjectPlacement::PlacesObject() const { return data_->getInverse(Type::IfcProduct, 5)->as(); } +IfcLocalPlacement::list::ptr IfcObjectPlacement::ReferencedByPlacements() const { return data_->getInverse(Type::IfcLocalPlacement, 0)->as(); } + +const IfcParse::entity& IfcObjectPlacement::declaration() const { return *IfcObjectPlacement_type; } Type::Enum IfcObjectPlacement::Class() { return Type::IfcObjectPlacement; } -IfcObjectPlacement::IfcObjectPlacement(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcObjectPlacement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcObjectPlacement::IfcObjectPlacement() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcObjectPlacement::IfcObjectPlacement(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcObjectPlacement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcObjectPlacement::IfcObjectPlacement() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcObjective -bool IfcObjective::hasBenchmarkValues() const { return !entity->getArgument(7)->isNull(); } -IfcMetric* IfcObjective::BenchmarkValues() const { return (IfcMetric*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcObjective::setBenchmarkValues(IfcMetric* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcObjective::hasResultValues() const { return !entity->getArgument(8)->isNull(); } -IfcMetric* IfcObjective::ResultValues() const { return (IfcMetric*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcObjective::setResultValues(IfcMetric* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -IfcObjectiveEnum::IfcObjectiveEnum IfcObjective::ObjectiveQualifier() const { return IfcObjectiveEnum::FromString(*entity->getArgument(9)); } -void IfcObjective::setObjectiveQualifier(IfcObjectiveEnum::IfcObjectiveEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcObjectiveEnum::ToString(v)); } -bool IfcObjective::hasUserDefinedQualifier() const { return !entity->getArgument(10)->isNull(); } -std::string IfcObjective::UserDefinedQualifier() const { return *entity->getArgument(10); } -void IfcObjective::setUserDefinedQualifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcObjective::is(Type::Enum v) const { return v == Type::IfcObjective || IfcConstraint::is(v); } -Type::Enum IfcObjective::type() const { return Type::IfcObjective; } +bool IfcObjective::hasBenchmarkValues() const { return !data_->getArgument(7)->isNull(); } +IfcMetric* IfcObjective::BenchmarkValues() const { return (IfcMetric*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcObjective::setBenchmarkValues(IfcMetric* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcObjective::hasResultValues() const { return !data_->getArgument(8)->isNull(); } +IfcMetric* IfcObjective::ResultValues() const { return (IfcMetric*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcObjective::setResultValues(IfcMetric* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +IfcObjectiveEnum::IfcObjectiveEnum IfcObjective::ObjectiveQualifier() const { return IfcObjectiveEnum::FromString(*data_->getArgument(9)); } +void IfcObjective::setObjectiveQualifier(IfcObjectiveEnum::IfcObjectiveEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcObjectiveEnum::ToString(v)); } +bool IfcObjective::hasUserDefinedQualifier() const { return !data_->getArgument(10)->isNull(); } +std::string IfcObjective::UserDefinedQualifier() const { return *data_->getArgument(10); } +void IfcObjective::setUserDefinedQualifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcObjective::declaration() const { return *IfcObjective_type; } Type::Enum IfcObjective::Class() { return Type::IfcObjective; } -IfcObjective::IfcObjective(IfcAbstractEntity* e) : IfcConstraint((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcObjective)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcObjective::IfcObjective(std::string v1_Name, boost::optional< std::string > v2_Description, IfcConstraintEnum::IfcConstraintEnum v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, IfcActorSelect* v5_CreatingActor, IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, IfcMetric* v8_BenchmarkValues, IfcMetric* v9_ResultValues, IfcObjectiveEnum::IfcObjectiveEnum v10_ObjectiveQualifier, boost::optional< std::string > v11_UserDefinedQualifier) : IfcConstraint((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,v3_ConstraintGrade,IfcConstraintEnum::ToString(v3_ConstraintGrade)); if (v4_ConstraintSource) { e->setArgument(3,(*v4_ConstraintSource)); } else { e->setArgument(3); } e->setArgument(4,(v5_CreatingActor)); e->setArgument(5,(v6_CreationTime)); if (v7_UserDefinedGrade) { e->setArgument(6,(*v7_UserDefinedGrade)); } else { e->setArgument(6); } e->setArgument(7,(v8_BenchmarkValues)); e->setArgument(8,(v9_ResultValues)); e->setArgument(9,v10_ObjectiveQualifier,IfcObjectiveEnum::ToString(v10_ObjectiveQualifier)); if (v11_UserDefinedQualifier) { e->setArgument(10,(*v11_UserDefinedQualifier)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcObjective::IfcObjective(IfcAbstractEntity* e) : IfcConstraint((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcObjective)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcObjective::IfcObjective(std::string v1_Name, boost::optional< std::string > v2_Description, IfcConstraintEnum::IfcConstraintEnum v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, IfcActorSelect* v5_CreatingActor, IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, IfcMetric* v8_BenchmarkValues, IfcMetric* v9_ResultValues, IfcObjectiveEnum::IfcObjectiveEnum v10_ObjectiveQualifier, boost::optional< std::string > v11_UserDefinedQualifier) : IfcConstraint((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,v3_ConstraintGrade,IfcConstraintEnum::ToString(v3_ConstraintGrade)); if (v4_ConstraintSource) { e->setArgument(3,(*v4_ConstraintSource)); } else { e->setArgument(3); } e->setArgument(4,(v5_CreatingActor)); e->setArgument(5,(v6_CreationTime)); if (v7_UserDefinedGrade) { e->setArgument(6,(*v7_UserDefinedGrade)); } else { e->setArgument(6); } e->setArgument(7,(v8_BenchmarkValues)); e->setArgument(8,(v9_ResultValues)); e->setArgument(9,v10_ObjectiveQualifier,IfcObjectiveEnum::ToString(v10_ObjectiveQualifier)); if (v11_UserDefinedQualifier) { e->setArgument(10,(*v11_UserDefinedQualifier)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOccupant -IfcOccupantTypeEnum::IfcOccupantTypeEnum IfcOccupant::PredefinedType() const { return IfcOccupantTypeEnum::FromString(*entity->getArgument(6)); } -void IfcOccupant::setPredefinedType(IfcOccupantTypeEnum::IfcOccupantTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcOccupantTypeEnum::ToString(v)); } -bool IfcOccupant::is(Type::Enum v) const { return v == Type::IfcOccupant || IfcActor::is(v); } -Type::Enum IfcOccupant::type() const { return Type::IfcOccupant; } +IfcOccupantTypeEnum::IfcOccupantTypeEnum IfcOccupant::PredefinedType() const { return IfcOccupantTypeEnum::FromString(*data_->getArgument(6)); } +void IfcOccupant::setPredefinedType(IfcOccupantTypeEnum::IfcOccupantTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcOccupantTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcOccupant::declaration() const { return *IfcOccupant_type; } Type::Enum IfcOccupant::Class() { return Type::IfcOccupant; } -IfcOccupant::IfcOccupant(IfcAbstractEntity* e) : IfcActor((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOccupant)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOccupant::IfcOccupant(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcActorSelect* v6_TheActor, IfcOccupantTypeEnum::IfcOccupantTypeEnum v7_PredefinedType) : IfcActor((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_TheActor)); e->setArgument(6,v7_PredefinedType,IfcOccupantTypeEnum::ToString(v7_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcOccupant::IfcOccupant(IfcAbstractEntity* e) : IfcActor((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOccupant)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOccupant::IfcOccupant(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcActorSelect* v6_TheActor, IfcOccupantTypeEnum::IfcOccupantTypeEnum v7_PredefinedType) : IfcActor((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_TheActor)); e->setArgument(6,v7_PredefinedType,IfcOccupantTypeEnum::ToString(v7_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOffsetCurve2D -IfcCurve* IfcOffsetCurve2D::BasisCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcOffsetCurve2D::setBasisCurve(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcOffsetCurve2D::Distance() const { return *entity->getArgument(1); } -void IfcOffsetCurve2D::setDistance(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcOffsetCurve2D::SelfIntersect() const { return *entity->getArgument(2); } -void IfcOffsetCurve2D::setSelfIntersect(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcOffsetCurve2D::is(Type::Enum v) const { return v == Type::IfcOffsetCurve2D || IfcCurve::is(v); } -Type::Enum IfcOffsetCurve2D::type() const { return Type::IfcOffsetCurve2D; } +IfcCurve* IfcOffsetCurve2D::BasisCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcOffsetCurve2D::setBasisCurve(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcOffsetCurve2D::Distance() const { return *data_->getArgument(1); } +void IfcOffsetCurve2D::setDistance(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcOffsetCurve2D::SelfIntersect() const { return *data_->getArgument(2); } +void IfcOffsetCurve2D::setSelfIntersect(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcOffsetCurve2D::declaration() const { return *IfcOffsetCurve2D_type; } Type::Enum IfcOffsetCurve2D::Class() { return Type::IfcOffsetCurve2D; } -IfcOffsetCurve2D::IfcOffsetCurve2D(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOffsetCurve2D)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOffsetCurve2D::IfcOffsetCurve2D(IfcCurve* v1_BasisCurve, double v2_Distance, bool v3_SelfIntersect) : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisCurve)); e->setArgument(1,(v2_Distance)); e->setArgument(2,(v3_SelfIntersect)); entity = e; EntityBuffer::Add(this); } +IfcOffsetCurve2D::IfcOffsetCurve2D(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOffsetCurve2D)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOffsetCurve2D::IfcOffsetCurve2D(IfcCurve* v1_BasisCurve, double v2_Distance, bool v3_SelfIntersect) : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisCurve)); e->setArgument(1,(v2_Distance)); e->setArgument(2,(v3_SelfIntersect)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOffsetCurve3D -IfcCurve* IfcOffsetCurve3D::BasisCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcOffsetCurve3D::setBasisCurve(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcOffsetCurve3D::Distance() const { return *entity->getArgument(1); } -void IfcOffsetCurve3D::setDistance(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcOffsetCurve3D::SelfIntersect() const { return *entity->getArgument(2); } -void IfcOffsetCurve3D::setSelfIntersect(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcDirection* IfcOffsetCurve3D::RefDirection() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcOffsetCurve3D::setRefDirection(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcOffsetCurve3D::is(Type::Enum v) const { return v == Type::IfcOffsetCurve3D || IfcCurve::is(v); } -Type::Enum IfcOffsetCurve3D::type() const { return Type::IfcOffsetCurve3D; } +IfcCurve* IfcOffsetCurve3D::BasisCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcOffsetCurve3D::setBasisCurve(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcOffsetCurve3D::Distance() const { return *data_->getArgument(1); } +void IfcOffsetCurve3D::setDistance(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcOffsetCurve3D::SelfIntersect() const { return *data_->getArgument(2); } +void IfcOffsetCurve3D::setSelfIntersect(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcDirection* IfcOffsetCurve3D::RefDirection() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcOffsetCurve3D::setRefDirection(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcOffsetCurve3D::declaration() const { return *IfcOffsetCurve3D_type; } Type::Enum IfcOffsetCurve3D::Class() { return Type::IfcOffsetCurve3D; } -IfcOffsetCurve3D::IfcOffsetCurve3D(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOffsetCurve3D)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOffsetCurve3D::IfcOffsetCurve3D(IfcCurve* v1_BasisCurve, double v2_Distance, bool v3_SelfIntersect, IfcDirection* v4_RefDirection) : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisCurve)); e->setArgument(1,(v2_Distance)); e->setArgument(2,(v3_SelfIntersect)); e->setArgument(3,(v4_RefDirection)); entity = e; EntityBuffer::Add(this); } +IfcOffsetCurve3D::IfcOffsetCurve3D(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOffsetCurve3D)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOffsetCurve3D::IfcOffsetCurve3D(IfcCurve* v1_BasisCurve, double v2_Distance, bool v3_SelfIntersect, IfcDirection* v4_RefDirection) : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisCurve)); e->setArgument(1,(v2_Distance)); e->setArgument(2,(v3_SelfIntersect)); e->setArgument(3,(v4_RefDirection)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOneDirectionRepeatFactor -IfcVector* IfcOneDirectionRepeatFactor::RepeatFactor() const { return (IfcVector*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcOneDirectionRepeatFactor::setRepeatFactor(IfcVector* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcOneDirectionRepeatFactor::is(Type::Enum v) const { return v == Type::IfcOneDirectionRepeatFactor || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcOneDirectionRepeatFactor::type() const { return Type::IfcOneDirectionRepeatFactor; } +IfcVector* IfcOneDirectionRepeatFactor::RepeatFactor() const { return (IfcVector*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcOneDirectionRepeatFactor::setRepeatFactor(IfcVector* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcOneDirectionRepeatFactor::declaration() const { return *IfcOneDirectionRepeatFactor_type; } Type::Enum IfcOneDirectionRepeatFactor::Class() { return Type::IfcOneDirectionRepeatFactor; } -IfcOneDirectionRepeatFactor::IfcOneDirectionRepeatFactor(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOneDirectionRepeatFactor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOneDirectionRepeatFactor::IfcOneDirectionRepeatFactor(IfcVector* v1_RepeatFactor) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatFactor)); entity = e; EntityBuffer::Add(this); } +IfcOneDirectionRepeatFactor::IfcOneDirectionRepeatFactor(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOneDirectionRepeatFactor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOneDirectionRepeatFactor::IfcOneDirectionRepeatFactor(IfcVector* v1_RepeatFactor) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatFactor)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOpenShell -bool IfcOpenShell::is(Type::Enum v) const { return v == Type::IfcOpenShell || IfcConnectedFaceSet::is(v); } -Type::Enum IfcOpenShell::type() const { return Type::IfcOpenShell; } + + +const IfcParse::entity& IfcOpenShell::declaration() const { return *IfcOpenShell_type; } Type::Enum IfcOpenShell::Class() { return Type::IfcOpenShell; } -IfcOpenShell::IfcOpenShell(IfcAbstractEntity* e) : IfcConnectedFaceSet((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOpenShell)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOpenShell::IfcOpenShell(IfcTemplatedEntityList< IfcFace >::ptr v1_CfsFaces) : IfcConnectedFaceSet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_CfsFaces)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcOpenShell::IfcOpenShell(IfcAbstractEntity* e) : IfcConnectedFaceSet((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOpenShell)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOpenShell::IfcOpenShell(IfcTemplatedEntityList< IfcFace >::ptr v1_CfsFaces) : IfcConnectedFaceSet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_CfsFaces)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOpeningElement -IfcRelFillsElement::list::ptr IfcOpeningElement::HasFillings() const { return entity->getInverse(Type::IfcRelFillsElement, 4)->as(); } -bool IfcOpeningElement::is(Type::Enum v) const { return v == Type::IfcOpeningElement || IfcFeatureElementSubtraction::is(v); } -Type::Enum IfcOpeningElement::type() const { return Type::IfcOpeningElement; } + +IfcRelFillsElement::list::ptr IfcOpeningElement::HasFillings() const { return data_->getInverse(Type::IfcRelFillsElement, 4)->as(); } + +const IfcParse::entity& IfcOpeningElement::declaration() const { return *IfcOpeningElement_type; } Type::Enum IfcOpeningElement::Class() { return Type::IfcOpeningElement; } -IfcOpeningElement::IfcOpeningElement(IfcAbstractEntity* e) : IfcFeatureElementSubtraction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOpeningElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOpeningElement::IfcOpeningElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElementSubtraction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcOpeningElement::IfcOpeningElement(IfcAbstractEntity* e) : IfcFeatureElementSubtraction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOpeningElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOpeningElement::IfcOpeningElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElementSubtraction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOpticalMaterialProperties -bool IfcOpticalMaterialProperties::hasVisibleTransmittance() const { return !entity->getArgument(1)->isNull(); } -double IfcOpticalMaterialProperties::VisibleTransmittance() const { return *entity->getArgument(1); } -void IfcOpticalMaterialProperties::setVisibleTransmittance(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcOpticalMaterialProperties::hasSolarTransmittance() const { return !entity->getArgument(2)->isNull(); } -double IfcOpticalMaterialProperties::SolarTransmittance() const { return *entity->getArgument(2); } -void IfcOpticalMaterialProperties::setSolarTransmittance(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcOpticalMaterialProperties::hasThermalIrTransmittance() const { return !entity->getArgument(3)->isNull(); } -double IfcOpticalMaterialProperties::ThermalIrTransmittance() const { return *entity->getArgument(3); } -void IfcOpticalMaterialProperties::setThermalIrTransmittance(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcOpticalMaterialProperties::hasThermalIrEmissivityBack() const { return !entity->getArgument(4)->isNull(); } -double IfcOpticalMaterialProperties::ThermalIrEmissivityBack() const { return *entity->getArgument(4); } -void IfcOpticalMaterialProperties::setThermalIrEmissivityBack(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcOpticalMaterialProperties::hasThermalIrEmissivityFront() const { return !entity->getArgument(5)->isNull(); } -double IfcOpticalMaterialProperties::ThermalIrEmissivityFront() const { return *entity->getArgument(5); } -void IfcOpticalMaterialProperties::setThermalIrEmissivityFront(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcOpticalMaterialProperties::hasVisibleReflectanceBack() const { return !entity->getArgument(6)->isNull(); } -double IfcOpticalMaterialProperties::VisibleReflectanceBack() const { return *entity->getArgument(6); } -void IfcOpticalMaterialProperties::setVisibleReflectanceBack(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcOpticalMaterialProperties::hasVisibleReflectanceFront() const { return !entity->getArgument(7)->isNull(); } -double IfcOpticalMaterialProperties::VisibleReflectanceFront() const { return *entity->getArgument(7); } -void IfcOpticalMaterialProperties::setVisibleReflectanceFront(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcOpticalMaterialProperties::hasSolarReflectanceFront() const { return !entity->getArgument(8)->isNull(); } -double IfcOpticalMaterialProperties::SolarReflectanceFront() const { return *entity->getArgument(8); } -void IfcOpticalMaterialProperties::setSolarReflectanceFront(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcOpticalMaterialProperties::hasSolarReflectanceBack() const { return !entity->getArgument(9)->isNull(); } -double IfcOpticalMaterialProperties::SolarReflectanceBack() const { return *entity->getArgument(9); } -void IfcOpticalMaterialProperties::setSolarReflectanceBack(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcOpticalMaterialProperties::is(Type::Enum v) const { return v == Type::IfcOpticalMaterialProperties || IfcMaterialProperties::is(v); } -Type::Enum IfcOpticalMaterialProperties::type() const { return Type::IfcOpticalMaterialProperties; } +bool IfcOpticalMaterialProperties::hasVisibleTransmittance() const { return !data_->getArgument(1)->isNull(); } +double IfcOpticalMaterialProperties::VisibleTransmittance() const { return *data_->getArgument(1); } +void IfcOpticalMaterialProperties::setVisibleTransmittance(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcOpticalMaterialProperties::hasSolarTransmittance() const { return !data_->getArgument(2)->isNull(); } +double IfcOpticalMaterialProperties::SolarTransmittance() const { return *data_->getArgument(2); } +void IfcOpticalMaterialProperties::setSolarTransmittance(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcOpticalMaterialProperties::hasThermalIrTransmittance() const { return !data_->getArgument(3)->isNull(); } +double IfcOpticalMaterialProperties::ThermalIrTransmittance() const { return *data_->getArgument(3); } +void IfcOpticalMaterialProperties::setThermalIrTransmittance(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcOpticalMaterialProperties::hasThermalIrEmissivityBack() const { return !data_->getArgument(4)->isNull(); } +double IfcOpticalMaterialProperties::ThermalIrEmissivityBack() const { return *data_->getArgument(4); } +void IfcOpticalMaterialProperties::setThermalIrEmissivityBack(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcOpticalMaterialProperties::hasThermalIrEmissivityFront() const { return !data_->getArgument(5)->isNull(); } +double IfcOpticalMaterialProperties::ThermalIrEmissivityFront() const { return *data_->getArgument(5); } +void IfcOpticalMaterialProperties::setThermalIrEmissivityFront(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcOpticalMaterialProperties::hasVisibleReflectanceBack() const { return !data_->getArgument(6)->isNull(); } +double IfcOpticalMaterialProperties::VisibleReflectanceBack() const { return *data_->getArgument(6); } +void IfcOpticalMaterialProperties::setVisibleReflectanceBack(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcOpticalMaterialProperties::hasVisibleReflectanceFront() const { return !data_->getArgument(7)->isNull(); } +double IfcOpticalMaterialProperties::VisibleReflectanceFront() const { return *data_->getArgument(7); } +void IfcOpticalMaterialProperties::setVisibleReflectanceFront(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcOpticalMaterialProperties::hasSolarReflectanceFront() const { return !data_->getArgument(8)->isNull(); } +double IfcOpticalMaterialProperties::SolarReflectanceFront() const { return *data_->getArgument(8); } +void IfcOpticalMaterialProperties::setSolarReflectanceFront(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcOpticalMaterialProperties::hasSolarReflectanceBack() const { return !data_->getArgument(9)->isNull(); } +double IfcOpticalMaterialProperties::SolarReflectanceBack() const { return *data_->getArgument(9); } +void IfcOpticalMaterialProperties::setSolarReflectanceBack(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcOpticalMaterialProperties::declaration() const { return *IfcOpticalMaterialProperties_type; } Type::Enum IfcOpticalMaterialProperties::Class() { return Type::IfcOpticalMaterialProperties; } -IfcOpticalMaterialProperties::IfcOpticalMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOpticalMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOpticalMaterialProperties::IfcOpticalMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_VisibleTransmittance, boost::optional< double > v3_SolarTransmittance, boost::optional< double > v4_ThermalIrTransmittance, boost::optional< double > v5_ThermalIrEmissivityBack, boost::optional< double > v6_ThermalIrEmissivityFront, boost::optional< double > v7_VisibleReflectanceBack, boost::optional< double > v8_VisibleReflectanceFront, boost::optional< double > v9_SolarReflectanceFront, boost::optional< double > v10_SolarReflectanceBack) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_VisibleTransmittance) { e->setArgument(1,(*v2_VisibleTransmittance)); } else { e->setArgument(1); } if (v3_SolarTransmittance) { e->setArgument(2,(*v3_SolarTransmittance)); } else { e->setArgument(2); } if (v4_ThermalIrTransmittance) { e->setArgument(3,(*v4_ThermalIrTransmittance)); } else { e->setArgument(3); } if (v5_ThermalIrEmissivityBack) { e->setArgument(4,(*v5_ThermalIrEmissivityBack)); } else { e->setArgument(4); } if (v6_ThermalIrEmissivityFront) { e->setArgument(5,(*v6_ThermalIrEmissivityFront)); } else { e->setArgument(5); } if (v7_VisibleReflectanceBack) { e->setArgument(6,(*v7_VisibleReflectanceBack)); } else { e->setArgument(6); } if (v8_VisibleReflectanceFront) { e->setArgument(7,(*v8_VisibleReflectanceFront)); } else { e->setArgument(7); } if (v9_SolarReflectanceFront) { e->setArgument(8,(*v9_SolarReflectanceFront)); } else { e->setArgument(8); } if (v10_SolarReflectanceBack) { e->setArgument(9,(*v10_SolarReflectanceBack)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcOpticalMaterialProperties::IfcOpticalMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOpticalMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOpticalMaterialProperties::IfcOpticalMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_VisibleTransmittance, boost::optional< double > v3_SolarTransmittance, boost::optional< double > v4_ThermalIrTransmittance, boost::optional< double > v5_ThermalIrEmissivityBack, boost::optional< double > v6_ThermalIrEmissivityFront, boost::optional< double > v7_VisibleReflectanceBack, boost::optional< double > v8_VisibleReflectanceFront, boost::optional< double > v9_SolarReflectanceFront, boost::optional< double > v10_SolarReflectanceBack) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_VisibleTransmittance) { e->setArgument(1,(*v2_VisibleTransmittance)); } else { e->setArgument(1); } if (v3_SolarTransmittance) { e->setArgument(2,(*v3_SolarTransmittance)); } else { e->setArgument(2); } if (v4_ThermalIrTransmittance) { e->setArgument(3,(*v4_ThermalIrTransmittance)); } else { e->setArgument(3); } if (v5_ThermalIrEmissivityBack) { e->setArgument(4,(*v5_ThermalIrEmissivityBack)); } else { e->setArgument(4); } if (v6_ThermalIrEmissivityFront) { e->setArgument(5,(*v6_ThermalIrEmissivityFront)); } else { e->setArgument(5); } if (v7_VisibleReflectanceBack) { e->setArgument(6,(*v7_VisibleReflectanceBack)); } else { e->setArgument(6); } if (v8_VisibleReflectanceFront) { e->setArgument(7,(*v8_VisibleReflectanceFront)); } else { e->setArgument(7); } if (v9_SolarReflectanceFront) { e->setArgument(8,(*v9_SolarReflectanceFront)); } else { e->setArgument(8); } if (v10_SolarReflectanceBack) { e->setArgument(9,(*v10_SolarReflectanceBack)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOrderAction -std::string IfcOrderAction::ActionID() const { return *entity->getArgument(10); } -void IfcOrderAction::setActionID(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcOrderAction::is(Type::Enum v) const { return v == Type::IfcOrderAction || IfcTask::is(v); } -Type::Enum IfcOrderAction::type() const { return Type::IfcOrderAction; } +std::string IfcOrderAction::ActionID() const { return *data_->getArgument(10); } +void IfcOrderAction::setActionID(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcOrderAction::declaration() const { return *IfcOrderAction_type; } Type::Enum IfcOrderAction::Class() { return Type::IfcOrderAction; } -IfcOrderAction::IfcOrderAction(IfcAbstractEntity* e) : IfcTask((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOrderAction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOrderAction::IfcOrderAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority, std::string v11_ActionID) : IfcTask((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_TaskId)); if (v7_Status) { e->setArgument(6,(*v7_Status)); } else { e->setArgument(6); } if (v8_WorkMethod) { e->setArgument(7,(*v8_WorkMethod)); } else { e->setArgument(7); } e->setArgument(8,(v9_IsMilestone)); if (v10_Priority) { e->setArgument(9,(*v10_Priority)); } else { e->setArgument(9); } e->setArgument(10,(v11_ActionID)); entity = e; EntityBuffer::Add(this); } +IfcOrderAction::IfcOrderAction(IfcAbstractEntity* e) : IfcTask((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOrderAction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOrderAction::IfcOrderAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority, std::string v11_ActionID) : IfcTask((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_TaskId)); if (v7_Status) { e->setArgument(6,(*v7_Status)); } else { e->setArgument(6); } if (v8_WorkMethod) { e->setArgument(7,(*v8_WorkMethod)); } else { e->setArgument(7); } e->setArgument(8,(v9_IsMilestone)); if (v10_Priority) { e->setArgument(9,(*v10_Priority)); } else { e->setArgument(9); } e->setArgument(10,(v11_ActionID)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOrganization -bool IfcOrganization::hasId() const { return !entity->getArgument(0)->isNull(); } -std::string IfcOrganization::Id() const { return *entity->getArgument(0); } -void IfcOrganization::setId(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -std::string IfcOrganization::Name() const { return *entity->getArgument(1); } -void IfcOrganization::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcOrganization::hasDescription() const { return !entity->getArgument(2)->isNull(); } -std::string IfcOrganization::Description() const { return *entity->getArgument(2); } -void IfcOrganization::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcOrganization::hasRoles() const { return !entity->getArgument(3)->isNull(); } -IfcTemplatedEntityList< IfcActorRole >::ptr IfcOrganization::Roles() const { IfcEntityList::ptr es = *entity->getArgument(3); return es->as(); } -void IfcOrganization::setRoles(IfcTemplatedEntityList< IfcActorRole >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v->generalize()); } -bool IfcOrganization::hasAddresses() const { return !entity->getArgument(4)->isNull(); } -IfcTemplatedEntityList< IfcAddress >::ptr IfcOrganization::Addresses() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcOrganization::setAddresses(IfcTemplatedEntityList< IfcAddress >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -IfcOrganizationRelationship::list::ptr IfcOrganization::IsRelatedBy() const { return entity->getInverse(Type::IfcOrganizationRelationship, 3)->as(); } -IfcOrganizationRelationship::list::ptr IfcOrganization::Relates() const { return entity->getInverse(Type::IfcOrganizationRelationship, 2)->as(); } -IfcPersonAndOrganization::list::ptr IfcOrganization::Engages() const { return entity->getInverse(Type::IfcPersonAndOrganization, 1)->as(); } -bool IfcOrganization::is(Type::Enum v) const { return v == Type::IfcOrganization; } -Type::Enum IfcOrganization::type() const { return Type::IfcOrganization; } +bool IfcOrganization::hasId() const { return !data_->getArgument(0)->isNull(); } +std::string IfcOrganization::Id() const { return *data_->getArgument(0); } +void IfcOrganization::setId(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +std::string IfcOrganization::Name() const { return *data_->getArgument(1); } +void IfcOrganization::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcOrganization::hasDescription() const { return !data_->getArgument(2)->isNull(); } +std::string IfcOrganization::Description() const { return *data_->getArgument(2); } +void IfcOrganization::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcOrganization::hasRoles() const { return !data_->getArgument(3)->isNull(); } +IfcTemplatedEntityList< IfcActorRole >::ptr IfcOrganization::Roles() const { IfcEntityList::ptr es = *data_->getArgument(3); return es->as(); } +void IfcOrganization::setRoles(IfcTemplatedEntityList< IfcActorRole >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v->generalize()); } +bool IfcOrganization::hasAddresses() const { return !data_->getArgument(4)->isNull(); } +IfcTemplatedEntityList< IfcAddress >::ptr IfcOrganization::Addresses() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcOrganization::setAddresses(IfcTemplatedEntityList< IfcAddress >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } + +IfcOrganizationRelationship::list::ptr IfcOrganization::IsRelatedBy() const { return data_->getInverse(Type::IfcOrganizationRelationship, 3)->as(); } +IfcOrganizationRelationship::list::ptr IfcOrganization::Relates() const { return data_->getInverse(Type::IfcOrganizationRelationship, 2)->as(); } +IfcPersonAndOrganization::list::ptr IfcOrganization::Engages() const { return data_->getInverse(Type::IfcPersonAndOrganization, 1)->as(); } + +const IfcParse::entity& IfcOrganization::declaration() const { return *IfcOrganization_type; } Type::Enum IfcOrganization::Class() { return Type::IfcOrganization; } -IfcOrganization::IfcOrganization(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcOrganization)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOrganization::IfcOrganization(boost::optional< std::string > v1_Id, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< IfcTemplatedEntityList< IfcActorRole >::ptr > v4_Roles, boost::optional< IfcTemplatedEntityList< IfcAddress >::ptr > v5_Addresses) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Id) { e->setArgument(0,(*v1_Id)); } else { e->setArgument(0); } e->setArgument(1,(v2_Name)); if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } if (v4_Roles) { e->setArgument(3,(*v4_Roles)->generalize()); } else { e->setArgument(3); } if (v5_Addresses) { e->setArgument(4,(*v5_Addresses)->generalize()); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcOrganization::IfcOrganization(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcOrganization)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOrganization::IfcOrganization(boost::optional< std::string > v1_Id, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< IfcTemplatedEntityList< IfcActorRole >::ptr > v4_Roles, boost::optional< IfcTemplatedEntityList< IfcAddress >::ptr > v5_Addresses) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Id) { e->setArgument(0,(*v1_Id)); } else { e->setArgument(0); } e->setArgument(1,(v2_Name)); if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } if (v4_Roles) { e->setArgument(3,(*v4_Roles)->generalize()); } else { e->setArgument(3); } if (v5_Addresses) { e->setArgument(4,(*v5_Addresses)->generalize()); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOrganizationRelationship -std::string IfcOrganizationRelationship::Name() const { return *entity->getArgument(0); } -void IfcOrganizationRelationship::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcOrganizationRelationship::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcOrganizationRelationship::Description() const { return *entity->getArgument(1); } -void IfcOrganizationRelationship::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcOrganization* IfcOrganizationRelationship::RelatingOrganization() const { return (IfcOrganization*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcOrganizationRelationship::setRelatingOrganization(IfcOrganization* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcTemplatedEntityList< IfcOrganization >::ptr IfcOrganizationRelationship::RelatedOrganizations() const { IfcEntityList::ptr es = *entity->getArgument(3); return es->as(); } -void IfcOrganizationRelationship::setRelatedOrganizations(IfcTemplatedEntityList< IfcOrganization >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v->generalize()); } -bool IfcOrganizationRelationship::is(Type::Enum v) const { return v == Type::IfcOrganizationRelationship; } -Type::Enum IfcOrganizationRelationship::type() const { return Type::IfcOrganizationRelationship; } +std::string IfcOrganizationRelationship::Name() const { return *data_->getArgument(0); } +void IfcOrganizationRelationship::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcOrganizationRelationship::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcOrganizationRelationship::Description() const { return *data_->getArgument(1); } +void IfcOrganizationRelationship::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcOrganization* IfcOrganizationRelationship::RelatingOrganization() const { return (IfcOrganization*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcOrganizationRelationship::setRelatingOrganization(IfcOrganization* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcTemplatedEntityList< IfcOrganization >::ptr IfcOrganizationRelationship::RelatedOrganizations() const { IfcEntityList::ptr es = *data_->getArgument(3); return es->as(); } +void IfcOrganizationRelationship::setRelatedOrganizations(IfcTemplatedEntityList< IfcOrganization >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v->generalize()); } + + +const IfcParse::entity& IfcOrganizationRelationship::declaration() const { return *IfcOrganizationRelationship_type; } Type::Enum IfcOrganizationRelationship::Class() { return Type::IfcOrganizationRelationship; } -IfcOrganizationRelationship::IfcOrganizationRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcOrganizationRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOrganizationRelationship::IfcOrganizationRelationship(std::string v1_Name, boost::optional< std::string > v2_Description, IfcOrganization* v3_RelatingOrganization, IfcTemplatedEntityList< IfcOrganization >::ptr v4_RelatedOrganizations) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingOrganization)); e->setArgument(3,(v4_RelatedOrganizations)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcOrganizationRelationship::IfcOrganizationRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcOrganizationRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOrganizationRelationship::IfcOrganizationRelationship(std::string v1_Name, boost::optional< std::string > v2_Description, IfcOrganization* v3_RelatingOrganization, IfcTemplatedEntityList< IfcOrganization >::ptr v4_RelatedOrganizations) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_RelatingOrganization)); e->setArgument(3,(v4_RelatedOrganizations)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOrientedEdge -IfcEdge* IfcOrientedEdge::EdgeElement() const { return (IfcEdge*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcOrientedEdge::setEdgeElement(IfcEdge* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcOrientedEdge::Orientation() const { return *entity->getArgument(3); } -void IfcOrientedEdge::setOrientation(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcOrientedEdge::is(Type::Enum v) const { return v == Type::IfcOrientedEdge || IfcEdge::is(v); } -Type::Enum IfcOrientedEdge::type() const { return Type::IfcOrientedEdge; } +IfcEdge* IfcOrientedEdge::EdgeElement() const { return (IfcEdge*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcOrientedEdge::setEdgeElement(IfcEdge* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcOrientedEdge::Orientation() const { return *data_->getArgument(3); } +void IfcOrientedEdge::setOrientation(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcOrientedEdge::declaration() const { return *IfcOrientedEdge_type; } Type::Enum IfcOrientedEdge::Class() { return Type::IfcOrientedEdge; } -IfcOrientedEdge::IfcOrientedEdge(IfcAbstractEntity* e) : IfcEdge((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOrientedEdge)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOrientedEdge::IfcOrientedEdge(IfcEdge* v3_EdgeElement, bool v4_Orientation) : IfcEdge((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgumentDerived(0); e->setArgumentDerived(1); e->setArgument(2,(v3_EdgeElement)); e->setArgument(3,(v4_Orientation)); entity = e; EntityBuffer::Add(this); } +IfcOrientedEdge::IfcOrientedEdge(IfcAbstractEntity* e) : IfcEdge((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOrientedEdge)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOrientedEdge::IfcOrientedEdge(IfcEdge* v3_EdgeElement, bool v4_Orientation) : IfcEdge((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgumentDerived(0); e->setArgumentDerived(1); e->setArgument(2,(v3_EdgeElement)); e->setArgument(3,(v4_Orientation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOutletType -IfcOutletTypeEnum::IfcOutletTypeEnum IfcOutletType::PredefinedType() const { return IfcOutletTypeEnum::FromString(*entity->getArgument(9)); } -void IfcOutletType::setPredefinedType(IfcOutletTypeEnum::IfcOutletTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcOutletTypeEnum::ToString(v)); } -bool IfcOutletType::is(Type::Enum v) const { return v == Type::IfcOutletType || IfcFlowTerminalType::is(v); } -Type::Enum IfcOutletType::type() const { return Type::IfcOutletType; } +IfcOutletTypeEnum::IfcOutletTypeEnum IfcOutletType::PredefinedType() const { return IfcOutletTypeEnum::FromString(*data_->getArgument(9)); } +void IfcOutletType::setPredefinedType(IfcOutletTypeEnum::IfcOutletTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcOutletTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcOutletType::declaration() const { return *IfcOutletType_type; } Type::Enum IfcOutletType::Class() { return Type::IfcOutletType; } -IfcOutletType::IfcOutletType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOutletType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOutletType::IfcOutletType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcOutletTypeEnum::IfcOutletTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcOutletTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcOutletType::IfcOutletType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOutletType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOutletType::IfcOutletType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcOutletTypeEnum::IfcOutletTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcOutletTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOwnerHistory -IfcPersonAndOrganization* IfcOwnerHistory::OwningUser() const { return (IfcPersonAndOrganization*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcOwnerHistory::setOwningUser(IfcPersonAndOrganization* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcApplication* IfcOwnerHistory::OwningApplication() const { return (IfcApplication*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcOwnerHistory::setOwningApplication(IfcApplication* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcOwnerHistory::hasState() const { return !entity->getArgument(2)->isNull(); } -IfcStateEnum::IfcStateEnum IfcOwnerHistory::State() const { return IfcStateEnum::FromString(*entity->getArgument(2)); } -void IfcOwnerHistory::setState(IfcStateEnum::IfcStateEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v,IfcStateEnum::ToString(v)); } -IfcChangeActionEnum::IfcChangeActionEnum IfcOwnerHistory::ChangeAction() const { return IfcChangeActionEnum::FromString(*entity->getArgument(3)); } -void IfcOwnerHistory::setChangeAction(IfcChangeActionEnum::IfcChangeActionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v,IfcChangeActionEnum::ToString(v)); } -bool IfcOwnerHistory::hasLastModifiedDate() const { return !entity->getArgument(4)->isNull(); } -int IfcOwnerHistory::LastModifiedDate() const { return *entity->getArgument(4); } -void IfcOwnerHistory::setLastModifiedDate(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcOwnerHistory::hasLastModifyingUser() const { return !entity->getArgument(5)->isNull(); } -IfcPersonAndOrganization* IfcOwnerHistory::LastModifyingUser() const { return (IfcPersonAndOrganization*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcOwnerHistory::setLastModifyingUser(IfcPersonAndOrganization* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcOwnerHistory::hasLastModifyingApplication() const { return !entity->getArgument(6)->isNull(); } -IfcApplication* IfcOwnerHistory::LastModifyingApplication() const { return (IfcApplication*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcOwnerHistory::setLastModifyingApplication(IfcApplication* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -int IfcOwnerHistory::CreationDate() const { return *entity->getArgument(7); } -void IfcOwnerHistory::setCreationDate(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcOwnerHistory::is(Type::Enum v) const { return v == Type::IfcOwnerHistory; } -Type::Enum IfcOwnerHistory::type() const { return Type::IfcOwnerHistory; } +IfcPersonAndOrganization* IfcOwnerHistory::OwningUser() const { return (IfcPersonAndOrganization*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcOwnerHistory::setOwningUser(IfcPersonAndOrganization* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcApplication* IfcOwnerHistory::OwningApplication() const { return (IfcApplication*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcOwnerHistory::setOwningApplication(IfcApplication* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcOwnerHistory::hasState() const { return !data_->getArgument(2)->isNull(); } +IfcStateEnum::IfcStateEnum IfcOwnerHistory::State() const { return IfcStateEnum::FromString(*data_->getArgument(2)); } +void IfcOwnerHistory::setState(IfcStateEnum::IfcStateEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v,IfcStateEnum::ToString(v)); } +IfcChangeActionEnum::IfcChangeActionEnum IfcOwnerHistory::ChangeAction() const { return IfcChangeActionEnum::FromString(*data_->getArgument(3)); } +void IfcOwnerHistory::setChangeAction(IfcChangeActionEnum::IfcChangeActionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v,IfcChangeActionEnum::ToString(v)); } +bool IfcOwnerHistory::hasLastModifiedDate() const { return !data_->getArgument(4)->isNull(); } +int IfcOwnerHistory::LastModifiedDate() const { return *data_->getArgument(4); } +void IfcOwnerHistory::setLastModifiedDate(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcOwnerHistory::hasLastModifyingUser() const { return !data_->getArgument(5)->isNull(); } +IfcPersonAndOrganization* IfcOwnerHistory::LastModifyingUser() const { return (IfcPersonAndOrganization*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcOwnerHistory::setLastModifyingUser(IfcPersonAndOrganization* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcOwnerHistory::hasLastModifyingApplication() const { return !data_->getArgument(6)->isNull(); } +IfcApplication* IfcOwnerHistory::LastModifyingApplication() const { return (IfcApplication*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcOwnerHistory::setLastModifyingApplication(IfcApplication* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +int IfcOwnerHistory::CreationDate() const { return *data_->getArgument(7); } +void IfcOwnerHistory::setCreationDate(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcOwnerHistory::declaration() const { return *IfcOwnerHistory_type; } Type::Enum IfcOwnerHistory::Class() { return Type::IfcOwnerHistory; } -IfcOwnerHistory::IfcOwnerHistory(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcOwnerHistory)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOwnerHistory::IfcOwnerHistory(IfcPersonAndOrganization* v1_OwningUser, IfcApplication* v2_OwningApplication, boost::optional< IfcStateEnum::IfcStateEnum > v3_State, IfcChangeActionEnum::IfcChangeActionEnum v4_ChangeAction, boost::optional< int > v5_LastModifiedDate, IfcPersonAndOrganization* v6_LastModifyingUser, IfcApplication* v7_LastModifyingApplication, int v8_CreationDate) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_OwningUser)); e->setArgument(1,(v2_OwningApplication)); if (v3_State) { e->setArgument(2,*v3_State,IfcStateEnum::ToString(*v3_State)); } else { e->setArgument(2); } e->setArgument(3,v4_ChangeAction,IfcChangeActionEnum::ToString(v4_ChangeAction)); if (v5_LastModifiedDate) { e->setArgument(4,(*v5_LastModifiedDate)); } else { e->setArgument(4); } e->setArgument(5,(v6_LastModifyingUser)); e->setArgument(6,(v7_LastModifyingApplication)); e->setArgument(7,(v8_CreationDate)); entity = e; EntityBuffer::Add(this); } +IfcOwnerHistory::IfcOwnerHistory(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcOwnerHistory)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOwnerHistory::IfcOwnerHistory(IfcPersonAndOrganization* v1_OwningUser, IfcApplication* v2_OwningApplication, boost::optional< IfcStateEnum::IfcStateEnum > v3_State, IfcChangeActionEnum::IfcChangeActionEnum v4_ChangeAction, boost::optional< int > v5_LastModifiedDate, IfcPersonAndOrganization* v6_LastModifyingUser, IfcApplication* v7_LastModifyingApplication, int v8_CreationDate) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_OwningUser)); e->setArgument(1,(v2_OwningApplication)); if (v3_State) { e->setArgument(2,*v3_State,IfcStateEnum::ToString(*v3_State)); } else { e->setArgument(2); } e->setArgument(3,v4_ChangeAction,IfcChangeActionEnum::ToString(v4_ChangeAction)); if (v5_LastModifiedDate) { e->setArgument(4,(*v5_LastModifiedDate)); } else { e->setArgument(4); } e->setArgument(5,(v6_LastModifyingUser)); e->setArgument(6,(v7_LastModifyingApplication)); e->setArgument(7,(v8_CreationDate)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcParameterizedProfileDef -IfcAxis2Placement2D* IfcParameterizedProfileDef::Position() const { return (IfcAxis2Placement2D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcParameterizedProfileDef::setPosition(IfcAxis2Placement2D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcParameterizedProfileDef::is(Type::Enum v) const { return v == Type::IfcParameterizedProfileDef || IfcProfileDef::is(v); } -Type::Enum IfcParameterizedProfileDef::type() const { return Type::IfcParameterizedProfileDef; } +IfcAxis2Placement2D* IfcParameterizedProfileDef::Position() const { return (IfcAxis2Placement2D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcParameterizedProfileDef::setPosition(IfcAxis2Placement2D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcParameterizedProfileDef::declaration() const { return *IfcParameterizedProfileDef_type; } Type::Enum IfcParameterizedProfileDef::Class() { return Type::IfcParameterizedProfileDef; } -IfcParameterizedProfileDef::IfcParameterizedProfileDef(IfcAbstractEntity* e) : IfcProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcParameterizedProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcParameterizedProfileDef::IfcParameterizedProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position) : IfcProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); entity = e; EntityBuffer::Add(this); } +IfcParameterizedProfileDef::IfcParameterizedProfileDef(IfcAbstractEntity* e) : IfcProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcParameterizedProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcParameterizedProfileDef::IfcParameterizedProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position) : IfcProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPath -IfcTemplatedEntityList< IfcOrientedEdge >::ptr IfcPath::EdgeList() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcPath::setEdgeList(IfcTemplatedEntityList< IfcOrientedEdge >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcPath::is(Type::Enum v) const { return v == Type::IfcPath || IfcTopologicalRepresentationItem::is(v); } -Type::Enum IfcPath::type() const { return Type::IfcPath; } +IfcTemplatedEntityList< IfcOrientedEdge >::ptr IfcPath::EdgeList() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcPath::setEdgeList(IfcTemplatedEntityList< IfcOrientedEdge >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcPath::declaration() const { return *IfcPath_type; } Type::Enum IfcPath::Class() { return Type::IfcPath; } -IfcPath::IfcPath(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPath)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPath::IfcPath(IfcTemplatedEntityList< IfcOrientedEdge >::ptr v1_EdgeList) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_EdgeList)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcPath::IfcPath(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPath)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPath::IfcPath(IfcTemplatedEntityList< IfcOrientedEdge >::ptr v1_EdgeList) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_EdgeList)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPerformanceHistory -std::string IfcPerformanceHistory::LifeCyclePhase() const { return *entity->getArgument(5); } -void IfcPerformanceHistory::setLifeCyclePhase(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcPerformanceHistory::is(Type::Enum v) const { return v == Type::IfcPerformanceHistory || IfcControl::is(v); } -Type::Enum IfcPerformanceHistory::type() const { return Type::IfcPerformanceHistory; } +std::string IfcPerformanceHistory::LifeCyclePhase() const { return *data_->getArgument(5); } +void IfcPerformanceHistory::setLifeCyclePhase(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcPerformanceHistory::declaration() const { return *IfcPerformanceHistory_type; } Type::Enum IfcPerformanceHistory::Class() { return Type::IfcPerformanceHistory; } -IfcPerformanceHistory::IfcPerformanceHistory(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPerformanceHistory)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPerformanceHistory::IfcPerformanceHistory(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_LifeCyclePhase) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_LifeCyclePhase)); entity = e; EntityBuffer::Add(this); } +IfcPerformanceHistory::IfcPerformanceHistory(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPerformanceHistory)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPerformanceHistory::IfcPerformanceHistory(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_LifeCyclePhase) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_LifeCyclePhase)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPermeableCoveringProperties -IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum IfcPermeableCoveringProperties::OperationType() const { return IfcPermeableCoveringOperationEnum::FromString(*entity->getArgument(4)); } -void IfcPermeableCoveringProperties::setOperationType(IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcPermeableCoveringOperationEnum::ToString(v)); } -IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum IfcPermeableCoveringProperties::PanelPosition() const { return IfcWindowPanelPositionEnum::FromString(*entity->getArgument(5)); } -void IfcPermeableCoveringProperties::setPanelPosition(IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcWindowPanelPositionEnum::ToString(v)); } -bool IfcPermeableCoveringProperties::hasFrameDepth() const { return !entity->getArgument(6)->isNull(); } -double IfcPermeableCoveringProperties::FrameDepth() const { return *entity->getArgument(6); } -void IfcPermeableCoveringProperties::setFrameDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcPermeableCoveringProperties::hasFrameThickness() const { return !entity->getArgument(7)->isNull(); } -double IfcPermeableCoveringProperties::FrameThickness() const { return *entity->getArgument(7); } -void IfcPermeableCoveringProperties::setFrameThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcPermeableCoveringProperties::hasShapeAspectStyle() const { return !entity->getArgument(8)->isNull(); } -IfcShapeAspect* IfcPermeableCoveringProperties::ShapeAspectStyle() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcPermeableCoveringProperties::setShapeAspectStyle(IfcShapeAspect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcPermeableCoveringProperties::is(Type::Enum v) const { return v == Type::IfcPermeableCoveringProperties || IfcPropertySetDefinition::is(v); } -Type::Enum IfcPermeableCoveringProperties::type() const { return Type::IfcPermeableCoveringProperties; } +IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum IfcPermeableCoveringProperties::OperationType() const { return IfcPermeableCoveringOperationEnum::FromString(*data_->getArgument(4)); } +void IfcPermeableCoveringProperties::setOperationType(IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcPermeableCoveringOperationEnum::ToString(v)); } +IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum IfcPermeableCoveringProperties::PanelPosition() const { return IfcWindowPanelPositionEnum::FromString(*data_->getArgument(5)); } +void IfcPermeableCoveringProperties::setPanelPosition(IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcWindowPanelPositionEnum::ToString(v)); } +bool IfcPermeableCoveringProperties::hasFrameDepth() const { return !data_->getArgument(6)->isNull(); } +double IfcPermeableCoveringProperties::FrameDepth() const { return *data_->getArgument(6); } +void IfcPermeableCoveringProperties::setFrameDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcPermeableCoveringProperties::hasFrameThickness() const { return !data_->getArgument(7)->isNull(); } +double IfcPermeableCoveringProperties::FrameThickness() const { return *data_->getArgument(7); } +void IfcPermeableCoveringProperties::setFrameThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcPermeableCoveringProperties::hasShapeAspectStyle() const { return !data_->getArgument(8)->isNull(); } +IfcShapeAspect* IfcPermeableCoveringProperties::ShapeAspectStyle() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcPermeableCoveringProperties::setShapeAspectStyle(IfcShapeAspect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcPermeableCoveringProperties::declaration() const { return *IfcPermeableCoveringProperties_type; } Type::Enum IfcPermeableCoveringProperties::Class() { return Type::IfcPermeableCoveringProperties; } -IfcPermeableCoveringProperties::IfcPermeableCoveringProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPermeableCoveringProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPermeableCoveringProperties::IfcPermeableCoveringProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum v5_OperationType, IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum v6_PanelPosition, boost::optional< double > v7_FrameDepth, boost::optional< double > v8_FrameThickness, IfcShapeAspect* v9_ShapeAspectStyle) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,v5_OperationType,IfcPermeableCoveringOperationEnum::ToString(v5_OperationType)); e->setArgument(5,v6_PanelPosition,IfcWindowPanelPositionEnum::ToString(v6_PanelPosition)); if (v7_FrameDepth) { e->setArgument(6,(*v7_FrameDepth)); } else { e->setArgument(6); } if (v8_FrameThickness) { e->setArgument(7,(*v8_FrameThickness)); } else { e->setArgument(7); } e->setArgument(8,(v9_ShapeAspectStyle)); entity = e; EntityBuffer::Add(this); } +IfcPermeableCoveringProperties::IfcPermeableCoveringProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPermeableCoveringProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPermeableCoveringProperties::IfcPermeableCoveringProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum v5_OperationType, IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum v6_PanelPosition, boost::optional< double > v7_FrameDepth, boost::optional< double > v8_FrameThickness, IfcShapeAspect* v9_ShapeAspectStyle) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,v5_OperationType,IfcPermeableCoveringOperationEnum::ToString(v5_OperationType)); e->setArgument(5,v6_PanelPosition,IfcWindowPanelPositionEnum::ToString(v6_PanelPosition)); if (v7_FrameDepth) { e->setArgument(6,(*v7_FrameDepth)); } else { e->setArgument(6); } if (v8_FrameThickness) { e->setArgument(7,(*v8_FrameThickness)); } else { e->setArgument(7); } e->setArgument(8,(v9_ShapeAspectStyle)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPermit -std::string IfcPermit::PermitID() const { return *entity->getArgument(5); } -void IfcPermit::setPermitID(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcPermit::is(Type::Enum v) const { return v == Type::IfcPermit || IfcControl::is(v); } -Type::Enum IfcPermit::type() const { return Type::IfcPermit; } +std::string IfcPermit::PermitID() const { return *data_->getArgument(5); } +void IfcPermit::setPermitID(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcPermit::declaration() const { return *IfcPermit_type; } Type::Enum IfcPermit::Class() { return Type::IfcPermit; } -IfcPermit::IfcPermit(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPermit)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPermit::IfcPermit(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_PermitID) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_PermitID)); entity = e; EntityBuffer::Add(this); } +IfcPermit::IfcPermit(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPermit)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPermit::IfcPermit(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_PermitID) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_PermitID)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPerson -bool IfcPerson::hasId() const { return !entity->getArgument(0)->isNull(); } -std::string IfcPerson::Id() const { return *entity->getArgument(0); } -void IfcPerson::setId(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcPerson::hasFamilyName() const { return !entity->getArgument(1)->isNull(); } -std::string IfcPerson::FamilyName() const { return *entity->getArgument(1); } -void IfcPerson::setFamilyName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcPerson::hasGivenName() const { return !entity->getArgument(2)->isNull(); } -std::string IfcPerson::GivenName() const { return *entity->getArgument(2); } -void IfcPerson::setGivenName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPerson::hasMiddleNames() const { return !entity->getArgument(3)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcPerson::MiddleNames() const { return *entity->getArgument(3); } -void IfcPerson::setMiddleNames(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPerson::hasPrefixTitles() const { return !entity->getArgument(4)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcPerson::PrefixTitles() const { return *entity->getArgument(4); } -void IfcPerson::setPrefixTitles(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcPerson::hasSuffixTitles() const { return !entity->getArgument(5)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcPerson::SuffixTitles() const { return *entity->getArgument(5); } -void IfcPerson::setSuffixTitles(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcPerson::hasRoles() const { return !entity->getArgument(6)->isNull(); } -IfcTemplatedEntityList< IfcActorRole >::ptr IfcPerson::Roles() const { IfcEntityList::ptr es = *entity->getArgument(6); return es->as(); } -void IfcPerson::setRoles(IfcTemplatedEntityList< IfcActorRole >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v->generalize()); } -bool IfcPerson::hasAddresses() const { return !entity->getArgument(7)->isNull(); } -IfcTemplatedEntityList< IfcAddress >::ptr IfcPerson::Addresses() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcPerson::setAddresses(IfcTemplatedEntityList< IfcAddress >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -IfcPersonAndOrganization::list::ptr IfcPerson::EngagedIn() const { return entity->getInverse(Type::IfcPersonAndOrganization, 0)->as(); } -bool IfcPerson::is(Type::Enum v) const { return v == Type::IfcPerson; } -Type::Enum IfcPerson::type() const { return Type::IfcPerson; } +bool IfcPerson::hasId() const { return !data_->getArgument(0)->isNull(); } +std::string IfcPerson::Id() const { return *data_->getArgument(0); } +void IfcPerson::setId(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcPerson::hasFamilyName() const { return !data_->getArgument(1)->isNull(); } +std::string IfcPerson::FamilyName() const { return *data_->getArgument(1); } +void IfcPerson::setFamilyName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcPerson::hasGivenName() const { return !data_->getArgument(2)->isNull(); } +std::string IfcPerson::GivenName() const { return *data_->getArgument(2); } +void IfcPerson::setGivenName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcPerson::hasMiddleNames() const { return !data_->getArgument(3)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcPerson::MiddleNames() const { return *data_->getArgument(3); } +void IfcPerson::setMiddleNames(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcPerson::hasPrefixTitles() const { return !data_->getArgument(4)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcPerson::PrefixTitles() const { return *data_->getArgument(4); } +void IfcPerson::setPrefixTitles(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcPerson::hasSuffixTitles() const { return !data_->getArgument(5)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcPerson::SuffixTitles() const { return *data_->getArgument(5); } +void IfcPerson::setSuffixTitles(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcPerson::hasRoles() const { return !data_->getArgument(6)->isNull(); } +IfcTemplatedEntityList< IfcActorRole >::ptr IfcPerson::Roles() const { IfcEntityList::ptr es = *data_->getArgument(6); return es->as(); } +void IfcPerson::setRoles(IfcTemplatedEntityList< IfcActorRole >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v->generalize()); } +bool IfcPerson::hasAddresses() const { return !data_->getArgument(7)->isNull(); } +IfcTemplatedEntityList< IfcAddress >::ptr IfcPerson::Addresses() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcPerson::setAddresses(IfcTemplatedEntityList< IfcAddress >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } + +IfcPersonAndOrganization::list::ptr IfcPerson::EngagedIn() const { return data_->getInverse(Type::IfcPersonAndOrganization, 0)->as(); } + +const IfcParse::entity& IfcPerson::declaration() const { return *IfcPerson_type; } Type::Enum IfcPerson::Class() { return Type::IfcPerson; } -IfcPerson::IfcPerson(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPerson)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPerson::IfcPerson(boost::optional< std::string > v1_Id, boost::optional< std::string > v2_FamilyName, boost::optional< std::string > v3_GivenName, boost::optional< std::vector< std::string > /*[1:?]*/ > v4_MiddleNames, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_PrefixTitles, boost::optional< std::vector< std::string > /*[1:?]*/ > v6_SuffixTitles, boost::optional< IfcTemplatedEntityList< IfcActorRole >::ptr > v7_Roles, boost::optional< IfcTemplatedEntityList< IfcAddress >::ptr > v8_Addresses) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Id) { e->setArgument(0,(*v1_Id)); } else { e->setArgument(0); } if (v2_FamilyName) { e->setArgument(1,(*v2_FamilyName)); } else { e->setArgument(1); } if (v3_GivenName) { e->setArgument(2,(*v3_GivenName)); } else { e->setArgument(2); } if (v4_MiddleNames) { e->setArgument(3,(*v4_MiddleNames)); } else { e->setArgument(3); } if (v5_PrefixTitles) { e->setArgument(4,(*v5_PrefixTitles)); } else { e->setArgument(4); } if (v6_SuffixTitles) { e->setArgument(5,(*v6_SuffixTitles)); } else { e->setArgument(5); } if (v7_Roles) { e->setArgument(6,(*v7_Roles)->generalize()); } else { e->setArgument(6); } if (v8_Addresses) { e->setArgument(7,(*v8_Addresses)->generalize()); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcPerson::IfcPerson(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPerson)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPerson::IfcPerson(boost::optional< std::string > v1_Id, boost::optional< std::string > v2_FamilyName, boost::optional< std::string > v3_GivenName, boost::optional< std::vector< std::string > /*[1:?]*/ > v4_MiddleNames, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_PrefixTitles, boost::optional< std::vector< std::string > /*[1:?]*/ > v6_SuffixTitles, boost::optional< IfcTemplatedEntityList< IfcActorRole >::ptr > v7_Roles, boost::optional< IfcTemplatedEntityList< IfcAddress >::ptr > v8_Addresses) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Id) { e->setArgument(0,(*v1_Id)); } else { e->setArgument(0); } if (v2_FamilyName) { e->setArgument(1,(*v2_FamilyName)); } else { e->setArgument(1); } if (v3_GivenName) { e->setArgument(2,(*v3_GivenName)); } else { e->setArgument(2); } if (v4_MiddleNames) { e->setArgument(3,(*v4_MiddleNames)); } else { e->setArgument(3); } if (v5_PrefixTitles) { e->setArgument(4,(*v5_PrefixTitles)); } else { e->setArgument(4); } if (v6_SuffixTitles) { e->setArgument(5,(*v6_SuffixTitles)); } else { e->setArgument(5); } if (v7_Roles) { e->setArgument(6,(*v7_Roles)->generalize()); } else { e->setArgument(6); } if (v8_Addresses) { e->setArgument(7,(*v8_Addresses)->generalize()); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPersonAndOrganization -IfcPerson* IfcPersonAndOrganization::ThePerson() const { return (IfcPerson*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcPersonAndOrganization::setThePerson(IfcPerson* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcOrganization* IfcPersonAndOrganization::TheOrganization() const { return (IfcOrganization*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcPersonAndOrganization::setTheOrganization(IfcOrganization* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcPersonAndOrganization::hasRoles() const { return !entity->getArgument(2)->isNull(); } -IfcTemplatedEntityList< IfcActorRole >::ptr IfcPersonAndOrganization::Roles() const { IfcEntityList::ptr es = *entity->getArgument(2); return es->as(); } -void IfcPersonAndOrganization::setRoles(IfcTemplatedEntityList< IfcActorRole >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v->generalize()); } -bool IfcPersonAndOrganization::is(Type::Enum v) const { return v == Type::IfcPersonAndOrganization; } -Type::Enum IfcPersonAndOrganization::type() const { return Type::IfcPersonAndOrganization; } +IfcPerson* IfcPersonAndOrganization::ThePerson() const { return (IfcPerson*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcPersonAndOrganization::setThePerson(IfcPerson* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcOrganization* IfcPersonAndOrganization::TheOrganization() const { return (IfcOrganization*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcPersonAndOrganization::setTheOrganization(IfcOrganization* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcPersonAndOrganization::hasRoles() const { return !data_->getArgument(2)->isNull(); } +IfcTemplatedEntityList< IfcActorRole >::ptr IfcPersonAndOrganization::Roles() const { IfcEntityList::ptr es = *data_->getArgument(2); return es->as(); } +void IfcPersonAndOrganization::setRoles(IfcTemplatedEntityList< IfcActorRole >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v->generalize()); } + + +const IfcParse::entity& IfcPersonAndOrganization::declaration() const { return *IfcPersonAndOrganization_type; } Type::Enum IfcPersonAndOrganization::Class() { return Type::IfcPersonAndOrganization; } -IfcPersonAndOrganization::IfcPersonAndOrganization(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPersonAndOrganization)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPersonAndOrganization::IfcPersonAndOrganization(IfcPerson* v1_ThePerson, IfcOrganization* v2_TheOrganization, boost::optional< IfcTemplatedEntityList< IfcActorRole >::ptr > v3_Roles) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ThePerson)); e->setArgument(1,(v2_TheOrganization)); if (v3_Roles) { e->setArgument(2,(*v3_Roles)->generalize()); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcPersonAndOrganization::IfcPersonAndOrganization(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPersonAndOrganization)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPersonAndOrganization::IfcPersonAndOrganization(IfcPerson* v1_ThePerson, IfcOrganization* v2_TheOrganization, boost::optional< IfcTemplatedEntityList< IfcActorRole >::ptr > v3_Roles) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ThePerson)); e->setArgument(1,(v2_TheOrganization)); if (v3_Roles) { e->setArgument(2,(*v3_Roles)->generalize()); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPhysicalComplexQuantity -IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr IfcPhysicalComplexQuantity::HasQuantities() const { IfcEntityList::ptr es = *entity->getArgument(2); return es->as(); } -void IfcPhysicalComplexQuantity::setHasQuantities(IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v->generalize()); } -std::string IfcPhysicalComplexQuantity::Discrimination() const { return *entity->getArgument(3); } -void IfcPhysicalComplexQuantity::setDiscrimination(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPhysicalComplexQuantity::hasQuality() const { return !entity->getArgument(4)->isNull(); } -std::string IfcPhysicalComplexQuantity::Quality() const { return *entity->getArgument(4); } -void IfcPhysicalComplexQuantity::setQuality(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcPhysicalComplexQuantity::hasUsage() const { return !entity->getArgument(5)->isNull(); } -std::string IfcPhysicalComplexQuantity::Usage() const { return *entity->getArgument(5); } -void IfcPhysicalComplexQuantity::setUsage(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcPhysicalComplexQuantity::is(Type::Enum v) const { return v == Type::IfcPhysicalComplexQuantity || IfcPhysicalQuantity::is(v); } -Type::Enum IfcPhysicalComplexQuantity::type() const { return Type::IfcPhysicalComplexQuantity; } +IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr IfcPhysicalComplexQuantity::HasQuantities() const { IfcEntityList::ptr es = *data_->getArgument(2); return es->as(); } +void IfcPhysicalComplexQuantity::setHasQuantities(IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v->generalize()); } +std::string IfcPhysicalComplexQuantity::Discrimination() const { return *data_->getArgument(3); } +void IfcPhysicalComplexQuantity::setDiscrimination(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcPhysicalComplexQuantity::hasQuality() const { return !data_->getArgument(4)->isNull(); } +std::string IfcPhysicalComplexQuantity::Quality() const { return *data_->getArgument(4); } +void IfcPhysicalComplexQuantity::setQuality(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcPhysicalComplexQuantity::hasUsage() const { return !data_->getArgument(5)->isNull(); } +std::string IfcPhysicalComplexQuantity::Usage() const { return *data_->getArgument(5); } +void IfcPhysicalComplexQuantity::setUsage(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcPhysicalComplexQuantity::declaration() const { return *IfcPhysicalComplexQuantity_type; } Type::Enum IfcPhysicalComplexQuantity::Class() { return Type::IfcPhysicalComplexQuantity; } -IfcPhysicalComplexQuantity::IfcPhysicalComplexQuantity(IfcAbstractEntity* e) : IfcPhysicalQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPhysicalComplexQuantity)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPhysicalComplexQuantity::IfcPhysicalComplexQuantity(std::string v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v3_HasQuantities, std::string v4_Discrimination, boost::optional< std::string > v5_Quality, boost::optional< std::string > v6_Usage) : IfcPhysicalQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_HasQuantities)->generalize()); e->setArgument(3,(v4_Discrimination)); if (v5_Quality) { e->setArgument(4,(*v5_Quality)); } else { e->setArgument(4); } if (v6_Usage) { e->setArgument(5,(*v6_Usage)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcPhysicalComplexQuantity::IfcPhysicalComplexQuantity(IfcAbstractEntity* e) : IfcPhysicalQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPhysicalComplexQuantity)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPhysicalComplexQuantity::IfcPhysicalComplexQuantity(std::string v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v3_HasQuantities, std::string v4_Discrimination, boost::optional< std::string > v5_Quality, boost::optional< std::string > v6_Usage) : IfcPhysicalQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_HasQuantities)->generalize()); e->setArgument(3,(v4_Discrimination)); if (v5_Quality) { e->setArgument(4,(*v5_Quality)); } else { e->setArgument(4); } if (v6_Usage) { e->setArgument(5,(*v6_Usage)); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPhysicalQuantity -std::string IfcPhysicalQuantity::Name() const { return *entity->getArgument(0); } -void IfcPhysicalQuantity::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcPhysicalQuantity::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcPhysicalQuantity::Description() const { return *entity->getArgument(1); } -void IfcPhysicalQuantity::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcPhysicalComplexQuantity::list::ptr IfcPhysicalQuantity::PartOfComplex() const { return entity->getInverse(Type::IfcPhysicalComplexQuantity, 2)->as(); } -bool IfcPhysicalQuantity::is(Type::Enum v) const { return v == Type::IfcPhysicalQuantity; } -Type::Enum IfcPhysicalQuantity::type() const { return Type::IfcPhysicalQuantity; } +std::string IfcPhysicalQuantity::Name() const { return *data_->getArgument(0); } +void IfcPhysicalQuantity::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcPhysicalQuantity::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcPhysicalQuantity::Description() const { return *data_->getArgument(1); } +void IfcPhysicalQuantity::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + +IfcPhysicalComplexQuantity::list::ptr IfcPhysicalQuantity::PartOfComplex() const { return data_->getInverse(Type::IfcPhysicalComplexQuantity, 2)->as(); } + +const IfcParse::entity& IfcPhysicalQuantity::declaration() const { return *IfcPhysicalQuantity_type; } Type::Enum IfcPhysicalQuantity::Class() { return Type::IfcPhysicalQuantity; } -IfcPhysicalQuantity::IfcPhysicalQuantity(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPhysicalQuantity)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPhysicalQuantity::IfcPhysicalQuantity(std::string v1_Name, boost::optional< std::string > v2_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } entity = e; EntityBuffer::Add(this); } +IfcPhysicalQuantity::IfcPhysicalQuantity(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPhysicalQuantity)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPhysicalQuantity::IfcPhysicalQuantity(std::string v1_Name, boost::optional< std::string > v2_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPhysicalSimpleQuantity -bool IfcPhysicalSimpleQuantity::hasUnit() const { return !entity->getArgument(2)->isNull(); } -IfcNamedUnit* IfcPhysicalSimpleQuantity::Unit() const { return (IfcNamedUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcPhysicalSimpleQuantity::setUnit(IfcNamedUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPhysicalSimpleQuantity::is(Type::Enum v) const { return v == Type::IfcPhysicalSimpleQuantity || IfcPhysicalQuantity::is(v); } -Type::Enum IfcPhysicalSimpleQuantity::type() const { return Type::IfcPhysicalSimpleQuantity; } +bool IfcPhysicalSimpleQuantity::hasUnit() const { return !data_->getArgument(2)->isNull(); } +IfcNamedUnit* IfcPhysicalSimpleQuantity::Unit() const { return (IfcNamedUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcPhysicalSimpleQuantity::setUnit(IfcNamedUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcPhysicalSimpleQuantity::declaration() const { return *IfcPhysicalSimpleQuantity_type; } Type::Enum IfcPhysicalSimpleQuantity::Class() { return Type::IfcPhysicalSimpleQuantity; } -IfcPhysicalSimpleQuantity::IfcPhysicalSimpleQuantity(IfcAbstractEntity* e) : IfcPhysicalQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPhysicalSimpleQuantity)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPhysicalSimpleQuantity::IfcPhysicalSimpleQuantity(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit) : IfcPhysicalQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); entity = e; EntityBuffer::Add(this); } +IfcPhysicalSimpleQuantity::IfcPhysicalSimpleQuantity(IfcAbstractEntity* e) : IfcPhysicalQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPhysicalSimpleQuantity)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPhysicalSimpleQuantity::IfcPhysicalSimpleQuantity(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit) : IfcPhysicalQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPile -IfcPileTypeEnum::IfcPileTypeEnum IfcPile::PredefinedType() const { return IfcPileTypeEnum::FromString(*entity->getArgument(8)); } -void IfcPile::setPredefinedType(IfcPileTypeEnum::IfcPileTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcPileTypeEnum::ToString(v)); } -bool IfcPile::hasConstructionType() const { return !entity->getArgument(9)->isNull(); } -IfcPileConstructionEnum::IfcPileConstructionEnum IfcPile::ConstructionType() const { return IfcPileConstructionEnum::FromString(*entity->getArgument(9)); } -void IfcPile::setConstructionType(IfcPileConstructionEnum::IfcPileConstructionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcPileConstructionEnum::ToString(v)); } -bool IfcPile::is(Type::Enum v) const { return v == Type::IfcPile || IfcBuildingElement::is(v); } -Type::Enum IfcPile::type() const { return Type::IfcPile; } +IfcPileTypeEnum::IfcPileTypeEnum IfcPile::PredefinedType() const { return IfcPileTypeEnum::FromString(*data_->getArgument(8)); } +void IfcPile::setPredefinedType(IfcPileTypeEnum::IfcPileTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcPileTypeEnum::ToString(v)); } +bool IfcPile::hasConstructionType() const { return !data_->getArgument(9)->isNull(); } +IfcPileConstructionEnum::IfcPileConstructionEnum IfcPile::ConstructionType() const { return IfcPileConstructionEnum::FromString(*data_->getArgument(9)); } +void IfcPile::setConstructionType(IfcPileConstructionEnum::IfcPileConstructionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcPileConstructionEnum::ToString(v)); } + + +const IfcParse::entity& IfcPile::declaration() const { return *IfcPile_type; } Type::Enum IfcPile::Class() { return Type::IfcPile; } -IfcPile::IfcPile(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPile)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPile::IfcPile(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcPileTypeEnum::IfcPileTypeEnum v9_PredefinedType, boost::optional< IfcPileConstructionEnum::IfcPileConstructionEnum > v10_ConstructionType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_PredefinedType,IfcPileTypeEnum::ToString(v9_PredefinedType)); if (v10_ConstructionType) { e->setArgument(9,*v10_ConstructionType,IfcPileConstructionEnum::ToString(*v10_ConstructionType)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcPile::IfcPile(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPile)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPile::IfcPile(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcPileTypeEnum::IfcPileTypeEnum v9_PredefinedType, boost::optional< IfcPileConstructionEnum::IfcPileConstructionEnum > v10_ConstructionType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_PredefinedType,IfcPileTypeEnum::ToString(v9_PredefinedType)); if (v10_ConstructionType) { e->setArgument(9,*v10_ConstructionType,IfcPileConstructionEnum::ToString(*v10_ConstructionType)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPipeFittingType -IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum IfcPipeFittingType::PredefinedType() const { return IfcPipeFittingTypeEnum::FromString(*entity->getArgument(9)); } -void IfcPipeFittingType::setPredefinedType(IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcPipeFittingTypeEnum::ToString(v)); } -bool IfcPipeFittingType::is(Type::Enum v) const { return v == Type::IfcPipeFittingType || IfcFlowFittingType::is(v); } -Type::Enum IfcPipeFittingType::type() const { return Type::IfcPipeFittingType; } +IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum IfcPipeFittingType::PredefinedType() const { return IfcPipeFittingTypeEnum::FromString(*data_->getArgument(9)); } +void IfcPipeFittingType::setPredefinedType(IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcPipeFittingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcPipeFittingType::declaration() const { return *IfcPipeFittingType_type; } Type::Enum IfcPipeFittingType::Class() { return Type::IfcPipeFittingType; } -IfcPipeFittingType::IfcPipeFittingType(IfcAbstractEntity* e) : IfcFlowFittingType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPipeFittingType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPipeFittingType::IfcPipeFittingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum v10_PredefinedType) : IfcFlowFittingType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcPipeFittingTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcPipeFittingType::IfcPipeFittingType(IfcAbstractEntity* e) : IfcFlowFittingType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPipeFittingType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPipeFittingType::IfcPipeFittingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum v10_PredefinedType) : IfcFlowFittingType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcPipeFittingTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPipeSegmentType -IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum IfcPipeSegmentType::PredefinedType() const { return IfcPipeSegmentTypeEnum::FromString(*entity->getArgument(9)); } -void IfcPipeSegmentType::setPredefinedType(IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcPipeSegmentTypeEnum::ToString(v)); } -bool IfcPipeSegmentType::is(Type::Enum v) const { return v == Type::IfcPipeSegmentType || IfcFlowSegmentType::is(v); } -Type::Enum IfcPipeSegmentType::type() const { return Type::IfcPipeSegmentType; } +IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum IfcPipeSegmentType::PredefinedType() const { return IfcPipeSegmentTypeEnum::FromString(*data_->getArgument(9)); } +void IfcPipeSegmentType::setPredefinedType(IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcPipeSegmentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcPipeSegmentType::declaration() const { return *IfcPipeSegmentType_type; } Type::Enum IfcPipeSegmentType::Class() { return Type::IfcPipeSegmentType; } -IfcPipeSegmentType::IfcPipeSegmentType(IfcAbstractEntity* e) : IfcFlowSegmentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPipeSegmentType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPipeSegmentType::IfcPipeSegmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum v10_PredefinedType) : IfcFlowSegmentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcPipeSegmentTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcPipeSegmentType::IfcPipeSegmentType(IfcAbstractEntity* e) : IfcFlowSegmentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPipeSegmentType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPipeSegmentType::IfcPipeSegmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum v10_PredefinedType) : IfcFlowSegmentType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcPipeSegmentTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPixelTexture -int IfcPixelTexture::Width() const { return *entity->getArgument(4); } -void IfcPixelTexture::setWidth(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -int IfcPixelTexture::Height() const { return *entity->getArgument(5); } -void IfcPixelTexture::setHeight(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -int IfcPixelTexture::ColourComponents() const { return *entity->getArgument(6); } -void IfcPixelTexture::setColourComponents(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -std::vector< boost::dynamic_bitset<> > /*[1:?]*/ IfcPixelTexture::Pixel() const { return *entity->getArgument(7); } -void IfcPixelTexture::setPixel(std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcPixelTexture::is(Type::Enum v) const { return v == Type::IfcPixelTexture || IfcSurfaceTexture::is(v); } -Type::Enum IfcPixelTexture::type() const { return Type::IfcPixelTexture; } +int IfcPixelTexture::Width() const { return *data_->getArgument(4); } +void IfcPixelTexture::setWidth(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +int IfcPixelTexture::Height() const { return *data_->getArgument(5); } +void IfcPixelTexture::setHeight(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +int IfcPixelTexture::ColourComponents() const { return *data_->getArgument(6); } +void IfcPixelTexture::setColourComponents(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +std::vector< boost::dynamic_bitset<> > /*[1:?]*/ IfcPixelTexture::Pixel() const { return *data_->getArgument(7); } +void IfcPixelTexture::setPixel(std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcPixelTexture::declaration() const { return *IfcPixelTexture_type; } Type::Enum IfcPixelTexture::Class() { return Type::IfcPixelTexture; } -IfcPixelTexture::IfcPixelTexture(IfcAbstractEntity* e) : IfcSurfaceTexture((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPixelTexture)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPixelTexture::IfcPixelTexture(bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform, int v5_Width, int v6_Height, int v7_ColourComponents, std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v8_Pixel) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); e->setArgument(2,v3_TextureType,IfcSurfaceTextureEnum::ToString(v3_TextureType)); e->setArgument(3,(v4_TextureTransform)); e->setArgument(4,(v5_Width)); e->setArgument(5,(v6_Height)); e->setArgument(6,(v7_ColourComponents)); e->setArgument(7,(v8_Pixel)); entity = e; EntityBuffer::Add(this); } +IfcPixelTexture::IfcPixelTexture(IfcAbstractEntity* e) : IfcSurfaceTexture((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPixelTexture)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPixelTexture::IfcPixelTexture(bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform, int v5_Width, int v6_Height, int v7_ColourComponents, std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v8_Pixel) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); e->setArgument(2,v3_TextureType,IfcSurfaceTextureEnum::ToString(v3_TextureType)); e->setArgument(3,(v4_TextureTransform)); e->setArgument(4,(v5_Width)); e->setArgument(5,(v6_Height)); e->setArgument(6,(v7_ColourComponents)); e->setArgument(7,(v8_Pixel)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPlacement -IfcCartesianPoint* IfcPlacement::Location() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcPlacement::setLocation(IfcCartesianPoint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcPlacement::is(Type::Enum v) const { return v == Type::IfcPlacement || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcPlacement::type() const { return Type::IfcPlacement; } +IfcCartesianPoint* IfcPlacement::Location() const { return (IfcCartesianPoint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcPlacement::setLocation(IfcCartesianPoint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcPlacement::declaration() const { return *IfcPlacement_type; } Type::Enum IfcPlacement::Class() { return Type::IfcPlacement; } -IfcPlacement::IfcPlacement(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlacement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPlacement::IfcPlacement(IfcCartesianPoint* v1_Location) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Location)); entity = e; EntityBuffer::Add(this); } +IfcPlacement::IfcPlacement(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlacement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPlacement::IfcPlacement(IfcCartesianPoint* v1_Location) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Location)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPlanarBox -IfcAxis2Placement* IfcPlanarBox::Placement() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcPlanarBox::setPlacement(IfcAxis2Placement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPlanarBox::is(Type::Enum v) const { return v == Type::IfcPlanarBox || IfcPlanarExtent::is(v); } -Type::Enum IfcPlanarBox::type() const { return Type::IfcPlanarBox; } +IfcAxis2Placement* IfcPlanarBox::Placement() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcPlanarBox::setPlacement(IfcAxis2Placement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcPlanarBox::declaration() const { return *IfcPlanarBox_type; } Type::Enum IfcPlanarBox::Class() { return Type::IfcPlanarBox; } -IfcPlanarBox::IfcPlanarBox(IfcAbstractEntity* e) : IfcPlanarExtent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlanarBox)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPlanarBox::IfcPlanarBox(double v1_SizeInX, double v2_SizeInY, IfcAxis2Placement* v3_Placement) : IfcPlanarExtent((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SizeInX)); e->setArgument(1,(v2_SizeInY)); e->setArgument(2,(v3_Placement)); entity = e; EntityBuffer::Add(this); } +IfcPlanarBox::IfcPlanarBox(IfcAbstractEntity* e) : IfcPlanarExtent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlanarBox)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPlanarBox::IfcPlanarBox(double v1_SizeInX, double v2_SizeInY, IfcAxis2Placement* v3_Placement) : IfcPlanarExtent((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SizeInX)); e->setArgument(1,(v2_SizeInY)); e->setArgument(2,(v3_Placement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPlanarExtent -double IfcPlanarExtent::SizeInX() const { return *entity->getArgument(0); } -void IfcPlanarExtent::setSizeInX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcPlanarExtent::SizeInY() const { return *entity->getArgument(1); } -void IfcPlanarExtent::setSizeInY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcPlanarExtent::is(Type::Enum v) const { return v == Type::IfcPlanarExtent || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcPlanarExtent::type() const { return Type::IfcPlanarExtent; } +double IfcPlanarExtent::SizeInX() const { return *data_->getArgument(0); } +void IfcPlanarExtent::setSizeInX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcPlanarExtent::SizeInY() const { return *data_->getArgument(1); } +void IfcPlanarExtent::setSizeInY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcPlanarExtent::declaration() const { return *IfcPlanarExtent_type; } Type::Enum IfcPlanarExtent::Class() { return Type::IfcPlanarExtent; } -IfcPlanarExtent::IfcPlanarExtent(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlanarExtent)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPlanarExtent::IfcPlanarExtent(double v1_SizeInX, double v2_SizeInY) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SizeInX)); e->setArgument(1,(v2_SizeInY)); entity = e; EntityBuffer::Add(this); } +IfcPlanarExtent::IfcPlanarExtent(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlanarExtent)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPlanarExtent::IfcPlanarExtent(double v1_SizeInX, double v2_SizeInY) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SizeInX)); e->setArgument(1,(v2_SizeInY)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPlane -bool IfcPlane::is(Type::Enum v) const { return v == Type::IfcPlane || IfcElementarySurface::is(v); } -Type::Enum IfcPlane::type() const { return Type::IfcPlane; } + + +const IfcParse::entity& IfcPlane::declaration() const { return *IfcPlane_type; } Type::Enum IfcPlane::Class() { return Type::IfcPlane; } -IfcPlane::IfcPlane(IfcAbstractEntity* e) : IfcElementarySurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlane)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPlane::IfcPlane(IfcAxis2Placement3D* v1_Position) : IfcElementarySurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); entity = e; EntityBuffer::Add(this); } +IfcPlane::IfcPlane(IfcAbstractEntity* e) : IfcElementarySurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlane)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPlane::IfcPlane(IfcAxis2Placement3D* v1_Position) : IfcElementarySurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPlate -bool IfcPlate::is(Type::Enum v) const { return v == Type::IfcPlate || IfcBuildingElement::is(v); } -Type::Enum IfcPlate::type() const { return Type::IfcPlate; } + + +const IfcParse::entity& IfcPlate::declaration() const { return *IfcPlate_type; } Type::Enum IfcPlate::Class() { return Type::IfcPlate; } -IfcPlate::IfcPlate(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlate)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPlate::IfcPlate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcPlate::IfcPlate(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlate)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPlate::IfcPlate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPlateType -IfcPlateTypeEnum::IfcPlateTypeEnum IfcPlateType::PredefinedType() const { return IfcPlateTypeEnum::FromString(*entity->getArgument(9)); } -void IfcPlateType::setPredefinedType(IfcPlateTypeEnum::IfcPlateTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcPlateTypeEnum::ToString(v)); } -bool IfcPlateType::is(Type::Enum v) const { return v == Type::IfcPlateType || IfcBuildingElementType::is(v); } -Type::Enum IfcPlateType::type() const { return Type::IfcPlateType; } +IfcPlateTypeEnum::IfcPlateTypeEnum IfcPlateType::PredefinedType() const { return IfcPlateTypeEnum::FromString(*data_->getArgument(9)); } +void IfcPlateType::setPredefinedType(IfcPlateTypeEnum::IfcPlateTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcPlateTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcPlateType::declaration() const { return *IfcPlateType_type; } Type::Enum IfcPlateType::Class() { return Type::IfcPlateType; } -IfcPlateType::IfcPlateType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlateType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPlateType::IfcPlateType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPlateTypeEnum::IfcPlateTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcPlateTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcPlateType::IfcPlateType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlateType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPlateType::IfcPlateType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPlateTypeEnum::IfcPlateTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcPlateTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPoint -bool IfcPoint::is(Type::Enum v) const { return v == Type::IfcPoint || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcPoint::type() const { return Type::IfcPoint; } + + +const IfcParse::entity& IfcPoint::declaration() const { return *IfcPoint_type; } Type::Enum IfcPoint::Class() { return Type::IfcPoint; } -IfcPoint::IfcPoint(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPoint)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPoint::IfcPoint() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcPoint::IfcPoint(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPoint)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPoint::IfcPoint() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPointOnCurve -IfcCurve* IfcPointOnCurve::BasisCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcPointOnCurve::setBasisCurve(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcPointOnCurve::PointParameter() const { return *entity->getArgument(1); } -void IfcPointOnCurve::setPointParameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcPointOnCurve::is(Type::Enum v) const { return v == Type::IfcPointOnCurve || IfcPoint::is(v); } -Type::Enum IfcPointOnCurve::type() const { return Type::IfcPointOnCurve; } +IfcCurve* IfcPointOnCurve::BasisCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcPointOnCurve::setBasisCurve(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcPointOnCurve::PointParameter() const { return *data_->getArgument(1); } +void IfcPointOnCurve::setPointParameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcPointOnCurve::declaration() const { return *IfcPointOnCurve_type; } Type::Enum IfcPointOnCurve::Class() { return Type::IfcPointOnCurve; } -IfcPointOnCurve::IfcPointOnCurve(IfcAbstractEntity* e) : IfcPoint((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPointOnCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPointOnCurve::IfcPointOnCurve(IfcCurve* v1_BasisCurve, double v2_PointParameter) : IfcPoint((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisCurve)); e->setArgument(1,(v2_PointParameter)); entity = e; EntityBuffer::Add(this); } +IfcPointOnCurve::IfcPointOnCurve(IfcAbstractEntity* e) : IfcPoint((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPointOnCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPointOnCurve::IfcPointOnCurve(IfcCurve* v1_BasisCurve, double v2_PointParameter) : IfcPoint((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisCurve)); e->setArgument(1,(v2_PointParameter)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPointOnSurface -IfcSurface* IfcPointOnSurface::BasisSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcPointOnSurface::setBasisSurface(IfcSurface* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcPointOnSurface::PointParameterU() const { return *entity->getArgument(1); } -void IfcPointOnSurface::setPointParameterU(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcPointOnSurface::PointParameterV() const { return *entity->getArgument(2); } -void IfcPointOnSurface::setPointParameterV(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPointOnSurface::is(Type::Enum v) const { return v == Type::IfcPointOnSurface || IfcPoint::is(v); } -Type::Enum IfcPointOnSurface::type() const { return Type::IfcPointOnSurface; } +IfcSurface* IfcPointOnSurface::BasisSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcPointOnSurface::setBasisSurface(IfcSurface* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcPointOnSurface::PointParameterU() const { return *data_->getArgument(1); } +void IfcPointOnSurface::setPointParameterU(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcPointOnSurface::PointParameterV() const { return *data_->getArgument(2); } +void IfcPointOnSurface::setPointParameterV(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcPointOnSurface::declaration() const { return *IfcPointOnSurface_type; } Type::Enum IfcPointOnSurface::Class() { return Type::IfcPointOnSurface; } -IfcPointOnSurface::IfcPointOnSurface(IfcAbstractEntity* e) : IfcPoint((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPointOnSurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPointOnSurface::IfcPointOnSurface(IfcSurface* v1_BasisSurface, double v2_PointParameterU, double v3_PointParameterV) : IfcPoint((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisSurface)); e->setArgument(1,(v2_PointParameterU)); e->setArgument(2,(v3_PointParameterV)); entity = e; EntityBuffer::Add(this); } +IfcPointOnSurface::IfcPointOnSurface(IfcAbstractEntity* e) : IfcPoint((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPointOnSurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPointOnSurface::IfcPointOnSurface(IfcSurface* v1_BasisSurface, double v2_PointParameterU, double v3_PointParameterV) : IfcPoint((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisSurface)); e->setArgument(1,(v2_PointParameterU)); e->setArgument(2,(v3_PointParameterV)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPolyLoop -IfcTemplatedEntityList< IfcCartesianPoint >::ptr IfcPolyLoop::Polygon() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcPolyLoop::setPolygon(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcPolyLoop::is(Type::Enum v) const { return v == Type::IfcPolyLoop || IfcLoop::is(v); } -Type::Enum IfcPolyLoop::type() const { return Type::IfcPolyLoop; } +IfcTemplatedEntityList< IfcCartesianPoint >::ptr IfcPolyLoop::Polygon() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcPolyLoop::setPolygon(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcPolyLoop::declaration() const { return *IfcPolyLoop_type; } Type::Enum IfcPolyLoop::Class() { return Type::IfcPolyLoop; } -IfcPolyLoop::IfcPolyLoop(IfcAbstractEntity* e) : IfcLoop((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPolyLoop)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPolyLoop::IfcPolyLoop(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v1_Polygon) : IfcLoop((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Polygon)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcPolyLoop::IfcPolyLoop(IfcAbstractEntity* e) : IfcLoop((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPolyLoop)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPolyLoop::IfcPolyLoop(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v1_Polygon) : IfcLoop((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Polygon)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPolygonalBoundedHalfSpace -IfcAxis2Placement3D* IfcPolygonalBoundedHalfSpace::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcPolygonalBoundedHalfSpace::setPosition(IfcAxis2Placement3D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcBoundedCurve* IfcPolygonalBoundedHalfSpace::PolygonalBoundary() const { return (IfcBoundedCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcPolygonalBoundedHalfSpace::setPolygonalBoundary(IfcBoundedCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPolygonalBoundedHalfSpace::is(Type::Enum v) const { return v == Type::IfcPolygonalBoundedHalfSpace || IfcHalfSpaceSolid::is(v); } -Type::Enum IfcPolygonalBoundedHalfSpace::type() const { return Type::IfcPolygonalBoundedHalfSpace; } +IfcAxis2Placement3D* IfcPolygonalBoundedHalfSpace::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcPolygonalBoundedHalfSpace::setPosition(IfcAxis2Placement3D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcBoundedCurve* IfcPolygonalBoundedHalfSpace::PolygonalBoundary() const { return (IfcBoundedCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcPolygonalBoundedHalfSpace::setPolygonalBoundary(IfcBoundedCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcPolygonalBoundedHalfSpace::declaration() const { return *IfcPolygonalBoundedHalfSpace_type; } Type::Enum IfcPolygonalBoundedHalfSpace::Class() { return Type::IfcPolygonalBoundedHalfSpace; } -IfcPolygonalBoundedHalfSpace::IfcPolygonalBoundedHalfSpace(IfcAbstractEntity* e) : IfcHalfSpaceSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPolygonalBoundedHalfSpace)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPolygonalBoundedHalfSpace::IfcPolygonalBoundedHalfSpace(IfcSurface* v1_BaseSurface, bool v2_AgreementFlag, IfcAxis2Placement3D* v3_Position, IfcBoundedCurve* v4_PolygonalBoundary) : IfcHalfSpaceSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BaseSurface)); e->setArgument(1,(v2_AgreementFlag)); e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_PolygonalBoundary)); entity = e; EntityBuffer::Add(this); } +IfcPolygonalBoundedHalfSpace::IfcPolygonalBoundedHalfSpace(IfcAbstractEntity* e) : IfcHalfSpaceSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPolygonalBoundedHalfSpace)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPolygonalBoundedHalfSpace::IfcPolygonalBoundedHalfSpace(IfcSurface* v1_BaseSurface, bool v2_AgreementFlag, IfcAxis2Placement3D* v3_Position, IfcBoundedCurve* v4_PolygonalBoundary) : IfcHalfSpaceSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BaseSurface)); e->setArgument(1,(v2_AgreementFlag)); e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_PolygonalBoundary)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPolyline -IfcTemplatedEntityList< IfcCartesianPoint >::ptr IfcPolyline::Points() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcPolyline::setPoints(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcPolyline::is(Type::Enum v) const { return v == Type::IfcPolyline || IfcBoundedCurve::is(v); } -Type::Enum IfcPolyline::type() const { return Type::IfcPolyline; } +IfcTemplatedEntityList< IfcCartesianPoint >::ptr IfcPolyline::Points() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcPolyline::setPoints(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcPolyline::declaration() const { return *IfcPolyline_type; } Type::Enum IfcPolyline::Class() { return Type::IfcPolyline; } -IfcPolyline::IfcPolyline(IfcAbstractEntity* e) : IfcBoundedCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPolyline)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPolyline::IfcPolyline(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v1_Points) : IfcBoundedCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Points)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcPolyline::IfcPolyline(IfcAbstractEntity* e) : IfcBoundedCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPolyline)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPolyline::IfcPolyline(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v1_Points) : IfcBoundedCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Points)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPort -IfcRelConnectsPortToElement::list::ptr IfcPort::ContainedIn() const { return entity->getInverse(Type::IfcRelConnectsPortToElement, 4)->as(); } -IfcRelConnectsPorts::list::ptr IfcPort::ConnectedFrom() const { return entity->getInverse(Type::IfcRelConnectsPorts, 5)->as(); } -IfcRelConnectsPorts::list::ptr IfcPort::ConnectedTo() const { return entity->getInverse(Type::IfcRelConnectsPorts, 4)->as(); } -bool IfcPort::is(Type::Enum v) const { return v == Type::IfcPort || IfcProduct::is(v); } -Type::Enum IfcPort::type() const { return Type::IfcPort; } + +IfcRelConnectsPortToElement::list::ptr IfcPort::ContainedIn() const { return data_->getInverse(Type::IfcRelConnectsPortToElement, 4)->as(); } +IfcRelConnectsPorts::list::ptr IfcPort::ConnectedFrom() const { return data_->getInverse(Type::IfcRelConnectsPorts, 5)->as(); } +IfcRelConnectsPorts::list::ptr IfcPort::ConnectedTo() const { return data_->getInverse(Type::IfcRelConnectsPorts, 4)->as(); } + +const IfcParse::entity& IfcPort::declaration() const { return *IfcPort_type; } Type::Enum IfcPort::Class() { return Type::IfcPort; } -IfcPort::IfcPort(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPort)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPort::IfcPort(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); entity = e; EntityBuffer::Add(this); } +IfcPort::IfcPort(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPort)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPort::IfcPort(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPostalAddress -bool IfcPostalAddress::hasInternalLocation() const { return !entity->getArgument(3)->isNull(); } -std::string IfcPostalAddress::InternalLocation() const { return *entity->getArgument(3); } -void IfcPostalAddress::setInternalLocation(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPostalAddress::hasAddressLines() const { return !entity->getArgument(4)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcPostalAddress::AddressLines() const { return *entity->getArgument(4); } -void IfcPostalAddress::setAddressLines(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcPostalAddress::hasPostalBox() const { return !entity->getArgument(5)->isNull(); } -std::string IfcPostalAddress::PostalBox() const { return *entity->getArgument(5); } -void IfcPostalAddress::setPostalBox(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcPostalAddress::hasTown() const { return !entity->getArgument(6)->isNull(); } -std::string IfcPostalAddress::Town() const { return *entity->getArgument(6); } -void IfcPostalAddress::setTown(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcPostalAddress::hasRegion() const { return !entity->getArgument(7)->isNull(); } -std::string IfcPostalAddress::Region() const { return *entity->getArgument(7); } -void IfcPostalAddress::setRegion(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcPostalAddress::hasPostalCode() const { return !entity->getArgument(8)->isNull(); } -std::string IfcPostalAddress::PostalCode() const { return *entity->getArgument(8); } -void IfcPostalAddress::setPostalCode(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcPostalAddress::hasCountry() const { return !entity->getArgument(9)->isNull(); } -std::string IfcPostalAddress::Country() const { return *entity->getArgument(9); } -void IfcPostalAddress::setCountry(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcPostalAddress::is(Type::Enum v) const { return v == Type::IfcPostalAddress || IfcAddress::is(v); } -Type::Enum IfcPostalAddress::type() const { return Type::IfcPostalAddress; } +bool IfcPostalAddress::hasInternalLocation() const { return !data_->getArgument(3)->isNull(); } +std::string IfcPostalAddress::InternalLocation() const { return *data_->getArgument(3); } +void IfcPostalAddress::setInternalLocation(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcPostalAddress::hasAddressLines() const { return !data_->getArgument(4)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcPostalAddress::AddressLines() const { return *data_->getArgument(4); } +void IfcPostalAddress::setAddressLines(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcPostalAddress::hasPostalBox() const { return !data_->getArgument(5)->isNull(); } +std::string IfcPostalAddress::PostalBox() const { return *data_->getArgument(5); } +void IfcPostalAddress::setPostalBox(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcPostalAddress::hasTown() const { return !data_->getArgument(6)->isNull(); } +std::string IfcPostalAddress::Town() const { return *data_->getArgument(6); } +void IfcPostalAddress::setTown(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcPostalAddress::hasRegion() const { return !data_->getArgument(7)->isNull(); } +std::string IfcPostalAddress::Region() const { return *data_->getArgument(7); } +void IfcPostalAddress::setRegion(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcPostalAddress::hasPostalCode() const { return !data_->getArgument(8)->isNull(); } +std::string IfcPostalAddress::PostalCode() const { return *data_->getArgument(8); } +void IfcPostalAddress::setPostalCode(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcPostalAddress::hasCountry() const { return !data_->getArgument(9)->isNull(); } +std::string IfcPostalAddress::Country() const { return *data_->getArgument(9); } +void IfcPostalAddress::setCountry(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcPostalAddress::declaration() const { return *IfcPostalAddress_type; } Type::Enum IfcPostalAddress::Class() { return Type::IfcPostalAddress; } -IfcPostalAddress::IfcPostalAddress(IfcAbstractEntity* e) : IfcAddress((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPostalAddress)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPostalAddress::IfcPostalAddress(boost::optional< IfcAddressTypeEnum::IfcAddressTypeEnum > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose, boost::optional< std::string > v4_InternalLocation, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_AddressLines, boost::optional< std::string > v6_PostalBox, boost::optional< std::string > v7_Town, boost::optional< std::string > v8_Region, boost::optional< std::string > v9_PostalCode, boost::optional< std::string > v10_Country) : IfcAddress((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Purpose) { e->setArgument(0,*v1_Purpose,IfcAddressTypeEnum::ToString(*v1_Purpose)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } if (v3_UserDefinedPurpose) { e->setArgument(2,(*v3_UserDefinedPurpose)); } else { e->setArgument(2); } if (v4_InternalLocation) { e->setArgument(3,(*v4_InternalLocation)); } else { e->setArgument(3); } if (v5_AddressLines) { e->setArgument(4,(*v5_AddressLines)); } else { e->setArgument(4); } if (v6_PostalBox) { e->setArgument(5,(*v6_PostalBox)); } else { e->setArgument(5); } if (v7_Town) { e->setArgument(6,(*v7_Town)); } else { e->setArgument(6); } if (v8_Region) { e->setArgument(7,(*v8_Region)); } else { e->setArgument(7); } if (v9_PostalCode) { e->setArgument(8,(*v9_PostalCode)); } else { e->setArgument(8); } if (v10_Country) { e->setArgument(9,(*v10_Country)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcPostalAddress::IfcPostalAddress(IfcAbstractEntity* e) : IfcAddress((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPostalAddress)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPostalAddress::IfcPostalAddress(boost::optional< IfcAddressTypeEnum::IfcAddressTypeEnum > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose, boost::optional< std::string > v4_InternalLocation, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_AddressLines, boost::optional< std::string > v6_PostalBox, boost::optional< std::string > v7_Town, boost::optional< std::string > v8_Region, boost::optional< std::string > v9_PostalCode, boost::optional< std::string > v10_Country) : IfcAddress((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Purpose) { e->setArgument(0,*v1_Purpose,IfcAddressTypeEnum::ToString(*v1_Purpose)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } if (v3_UserDefinedPurpose) { e->setArgument(2,(*v3_UserDefinedPurpose)); } else { e->setArgument(2); } if (v4_InternalLocation) { e->setArgument(3,(*v4_InternalLocation)); } else { e->setArgument(3); } if (v5_AddressLines) { e->setArgument(4,(*v5_AddressLines)); } else { e->setArgument(4); } if (v6_PostalBox) { e->setArgument(5,(*v6_PostalBox)); } else { e->setArgument(5); } if (v7_Town) { e->setArgument(6,(*v7_Town)); } else { e->setArgument(6); } if (v8_Region) { e->setArgument(7,(*v8_Region)); } else { e->setArgument(7); } if (v9_PostalCode) { e->setArgument(8,(*v9_PostalCode)); } else { e->setArgument(8); } if (v10_Country) { e->setArgument(9,(*v10_Country)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPreDefinedColour -bool IfcPreDefinedColour::is(Type::Enum v) const { return v == Type::IfcPreDefinedColour || IfcPreDefinedItem::is(v); } -Type::Enum IfcPreDefinedColour::type() const { return Type::IfcPreDefinedColour; } + + +const IfcParse::entity& IfcPreDefinedColour::declaration() const { return *IfcPreDefinedColour_type; } Type::Enum IfcPreDefinedColour::Class() { return Type::IfcPreDefinedColour; } -IfcPreDefinedColour::IfcPreDefinedColour(IfcAbstractEntity* e) : IfcPreDefinedItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedColour)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPreDefinedColour::IfcPreDefinedColour(std::string v1_Name) : IfcPreDefinedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcPreDefinedColour::IfcPreDefinedColour(IfcAbstractEntity* e) : IfcPreDefinedItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedColour)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPreDefinedColour::IfcPreDefinedColour(std::string v1_Name) : IfcPreDefinedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPreDefinedCurveFont -bool IfcPreDefinedCurveFont::is(Type::Enum v) const { return v == Type::IfcPreDefinedCurveFont || IfcPreDefinedItem::is(v); } -Type::Enum IfcPreDefinedCurveFont::type() const { return Type::IfcPreDefinedCurveFont; } + + +const IfcParse::entity& IfcPreDefinedCurveFont::declaration() const { return *IfcPreDefinedCurveFont_type; } Type::Enum IfcPreDefinedCurveFont::Class() { return Type::IfcPreDefinedCurveFont; } -IfcPreDefinedCurveFont::IfcPreDefinedCurveFont(IfcAbstractEntity* e) : IfcPreDefinedItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedCurveFont)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPreDefinedCurveFont::IfcPreDefinedCurveFont(std::string v1_Name) : IfcPreDefinedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcPreDefinedCurveFont::IfcPreDefinedCurveFont(IfcAbstractEntity* e) : IfcPreDefinedItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedCurveFont)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPreDefinedCurveFont::IfcPreDefinedCurveFont(std::string v1_Name) : IfcPreDefinedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPreDefinedDimensionSymbol -bool IfcPreDefinedDimensionSymbol::is(Type::Enum v) const { return v == Type::IfcPreDefinedDimensionSymbol || IfcPreDefinedSymbol::is(v); } -Type::Enum IfcPreDefinedDimensionSymbol::type() const { return Type::IfcPreDefinedDimensionSymbol; } + + +const IfcParse::entity& IfcPreDefinedDimensionSymbol::declaration() const { return *IfcPreDefinedDimensionSymbol_type; } Type::Enum IfcPreDefinedDimensionSymbol::Class() { return Type::IfcPreDefinedDimensionSymbol; } -IfcPreDefinedDimensionSymbol::IfcPreDefinedDimensionSymbol(IfcAbstractEntity* e) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedDimensionSymbol)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPreDefinedDimensionSymbol::IfcPreDefinedDimensionSymbol(std::string v1_Name) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcPreDefinedDimensionSymbol::IfcPreDefinedDimensionSymbol(IfcAbstractEntity* e) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedDimensionSymbol)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPreDefinedDimensionSymbol::IfcPreDefinedDimensionSymbol(std::string v1_Name) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPreDefinedItem -std::string IfcPreDefinedItem::Name() const { return *entity->getArgument(0); } -void IfcPreDefinedItem::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcPreDefinedItem::is(Type::Enum v) const { return v == Type::IfcPreDefinedItem; } -Type::Enum IfcPreDefinedItem::type() const { return Type::IfcPreDefinedItem; } +std::string IfcPreDefinedItem::Name() const { return *data_->getArgument(0); } +void IfcPreDefinedItem::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcPreDefinedItem::declaration() const { return *IfcPreDefinedItem_type; } Type::Enum IfcPreDefinedItem::Class() { return Type::IfcPreDefinedItem; } -IfcPreDefinedItem::IfcPreDefinedItem(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPreDefinedItem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPreDefinedItem::IfcPreDefinedItem(std::string v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcPreDefinedItem::IfcPreDefinedItem(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPreDefinedItem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPreDefinedItem::IfcPreDefinedItem(std::string v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPreDefinedPointMarkerSymbol -bool IfcPreDefinedPointMarkerSymbol::is(Type::Enum v) const { return v == Type::IfcPreDefinedPointMarkerSymbol || IfcPreDefinedSymbol::is(v); } -Type::Enum IfcPreDefinedPointMarkerSymbol::type() const { return Type::IfcPreDefinedPointMarkerSymbol; } + + +const IfcParse::entity& IfcPreDefinedPointMarkerSymbol::declaration() const { return *IfcPreDefinedPointMarkerSymbol_type; } Type::Enum IfcPreDefinedPointMarkerSymbol::Class() { return Type::IfcPreDefinedPointMarkerSymbol; } -IfcPreDefinedPointMarkerSymbol::IfcPreDefinedPointMarkerSymbol(IfcAbstractEntity* e) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedPointMarkerSymbol)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPreDefinedPointMarkerSymbol::IfcPreDefinedPointMarkerSymbol(std::string v1_Name) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcPreDefinedPointMarkerSymbol::IfcPreDefinedPointMarkerSymbol(IfcAbstractEntity* e) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedPointMarkerSymbol)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPreDefinedPointMarkerSymbol::IfcPreDefinedPointMarkerSymbol(std::string v1_Name) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPreDefinedSymbol -bool IfcPreDefinedSymbol::is(Type::Enum v) const { return v == Type::IfcPreDefinedSymbol || IfcPreDefinedItem::is(v); } -Type::Enum IfcPreDefinedSymbol::type() const { return Type::IfcPreDefinedSymbol; } + + +const IfcParse::entity& IfcPreDefinedSymbol::declaration() const { return *IfcPreDefinedSymbol_type; } Type::Enum IfcPreDefinedSymbol::Class() { return Type::IfcPreDefinedSymbol; } -IfcPreDefinedSymbol::IfcPreDefinedSymbol(IfcAbstractEntity* e) : IfcPreDefinedItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedSymbol)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPreDefinedSymbol::IfcPreDefinedSymbol(std::string v1_Name) : IfcPreDefinedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcPreDefinedSymbol::IfcPreDefinedSymbol(IfcAbstractEntity* e) : IfcPreDefinedItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedSymbol)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPreDefinedSymbol::IfcPreDefinedSymbol(std::string v1_Name) : IfcPreDefinedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPreDefinedTerminatorSymbol -bool IfcPreDefinedTerminatorSymbol::is(Type::Enum v) const { return v == Type::IfcPreDefinedTerminatorSymbol || IfcPreDefinedSymbol::is(v); } -Type::Enum IfcPreDefinedTerminatorSymbol::type() const { return Type::IfcPreDefinedTerminatorSymbol; } + + +const IfcParse::entity& IfcPreDefinedTerminatorSymbol::declaration() const { return *IfcPreDefinedTerminatorSymbol_type; } Type::Enum IfcPreDefinedTerminatorSymbol::Class() { return Type::IfcPreDefinedTerminatorSymbol; } -IfcPreDefinedTerminatorSymbol::IfcPreDefinedTerminatorSymbol(IfcAbstractEntity* e) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedTerminatorSymbol)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPreDefinedTerminatorSymbol::IfcPreDefinedTerminatorSymbol(std::string v1_Name) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcPreDefinedTerminatorSymbol::IfcPreDefinedTerminatorSymbol(IfcAbstractEntity* e) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedTerminatorSymbol)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPreDefinedTerminatorSymbol::IfcPreDefinedTerminatorSymbol(std::string v1_Name) : IfcPreDefinedSymbol((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPreDefinedTextFont -bool IfcPreDefinedTextFont::is(Type::Enum v) const { return v == Type::IfcPreDefinedTextFont || IfcPreDefinedItem::is(v); } -Type::Enum IfcPreDefinedTextFont::type() const { return Type::IfcPreDefinedTextFont; } + + +const IfcParse::entity& IfcPreDefinedTextFont::declaration() const { return *IfcPreDefinedTextFont_type; } Type::Enum IfcPreDefinedTextFont::Class() { return Type::IfcPreDefinedTextFont; } -IfcPreDefinedTextFont::IfcPreDefinedTextFont(IfcAbstractEntity* e) : IfcPreDefinedItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedTextFont)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPreDefinedTextFont::IfcPreDefinedTextFont(std::string v1_Name) : IfcPreDefinedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcPreDefinedTextFont::IfcPreDefinedTextFont(IfcAbstractEntity* e) : IfcPreDefinedItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedTextFont)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPreDefinedTextFont::IfcPreDefinedTextFont(std::string v1_Name) : IfcPreDefinedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPresentationLayerAssignment -std::string IfcPresentationLayerAssignment::Name() const { return *entity->getArgument(0); } -void IfcPresentationLayerAssignment::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcPresentationLayerAssignment::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcPresentationLayerAssignment::Description() const { return *entity->getArgument(1); } -void IfcPresentationLayerAssignment::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcEntityList::ptr IfcPresentationLayerAssignment::AssignedItems() const { return *entity->getArgument(2); } -void IfcPresentationLayerAssignment::setAssignedItems(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPresentationLayerAssignment::hasIdentifier() const { return !entity->getArgument(3)->isNull(); } -std::string IfcPresentationLayerAssignment::Identifier() const { return *entity->getArgument(3); } -void IfcPresentationLayerAssignment::setIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPresentationLayerAssignment::is(Type::Enum v) const { return v == Type::IfcPresentationLayerAssignment; } -Type::Enum IfcPresentationLayerAssignment::type() const { return Type::IfcPresentationLayerAssignment; } +std::string IfcPresentationLayerAssignment::Name() const { return *data_->getArgument(0); } +void IfcPresentationLayerAssignment::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcPresentationLayerAssignment::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcPresentationLayerAssignment::Description() const { return *data_->getArgument(1); } +void IfcPresentationLayerAssignment::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcEntityList::ptr IfcPresentationLayerAssignment::AssignedItems() const { return *data_->getArgument(2); } +void IfcPresentationLayerAssignment::setAssignedItems(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcPresentationLayerAssignment::hasIdentifier() const { return !data_->getArgument(3)->isNull(); } +std::string IfcPresentationLayerAssignment::Identifier() const { return *data_->getArgument(3); } +void IfcPresentationLayerAssignment::setIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcPresentationLayerAssignment::declaration() const { return *IfcPresentationLayerAssignment_type; } Type::Enum IfcPresentationLayerAssignment::Class() { return Type::IfcPresentationLayerAssignment; } -IfcPresentationLayerAssignment::IfcPresentationLayerAssignment(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPresentationLayerAssignment)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPresentationLayerAssignment::IfcPresentationLayerAssignment(std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_AssignedItems, boost::optional< std::string > v4_Identifier) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_AssignedItems)); if (v4_Identifier) { e->setArgument(3,(*v4_Identifier)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcPresentationLayerAssignment::IfcPresentationLayerAssignment(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPresentationLayerAssignment)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPresentationLayerAssignment::IfcPresentationLayerAssignment(std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_AssignedItems, boost::optional< std::string > v4_Identifier) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_AssignedItems)); if (v4_Identifier) { e->setArgument(3,(*v4_Identifier)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPresentationLayerWithStyle -bool IfcPresentationLayerWithStyle::LayerOn() const { return *entity->getArgument(4); } -void IfcPresentationLayerWithStyle::setLayerOn(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcPresentationLayerWithStyle::LayerFrozen() const { return *entity->getArgument(5); } -void IfcPresentationLayerWithStyle::setLayerFrozen(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcPresentationLayerWithStyle::LayerBlocked() const { return *entity->getArgument(6); } -void IfcPresentationLayerWithStyle::setLayerBlocked(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcEntityList::ptr IfcPresentationLayerWithStyle::LayerStyles() const { return *entity->getArgument(7); } -void IfcPresentationLayerWithStyle::setLayerStyles(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcPresentationLayerWithStyle::is(Type::Enum v) const { return v == Type::IfcPresentationLayerWithStyle || IfcPresentationLayerAssignment::is(v); } -Type::Enum IfcPresentationLayerWithStyle::type() const { return Type::IfcPresentationLayerWithStyle; } +bool IfcPresentationLayerWithStyle::LayerOn() const { return *data_->getArgument(4); } +void IfcPresentationLayerWithStyle::setLayerOn(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcPresentationLayerWithStyle::LayerFrozen() const { return *data_->getArgument(5); } +void IfcPresentationLayerWithStyle::setLayerFrozen(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcPresentationLayerWithStyle::LayerBlocked() const { return *data_->getArgument(6); } +void IfcPresentationLayerWithStyle::setLayerBlocked(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +IfcEntityList::ptr IfcPresentationLayerWithStyle::LayerStyles() const { return *data_->getArgument(7); } +void IfcPresentationLayerWithStyle::setLayerStyles(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcPresentationLayerWithStyle::declaration() const { return *IfcPresentationLayerWithStyle_type; } Type::Enum IfcPresentationLayerWithStyle::Class() { return Type::IfcPresentationLayerWithStyle; } -IfcPresentationLayerWithStyle::IfcPresentationLayerWithStyle(IfcAbstractEntity* e) : IfcPresentationLayerAssignment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPresentationLayerWithStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPresentationLayerWithStyle::IfcPresentationLayerWithStyle(std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_AssignedItems, boost::optional< std::string > v4_Identifier, bool v5_LayerOn, bool v6_LayerFrozen, bool v7_LayerBlocked, IfcEntityList::ptr v8_LayerStyles) : IfcPresentationLayerAssignment((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_AssignedItems)); if (v4_Identifier) { e->setArgument(3,(*v4_Identifier)); } else { e->setArgument(3); } e->setArgument(4,(v5_LayerOn)); e->setArgument(5,(v6_LayerFrozen)); e->setArgument(6,(v7_LayerBlocked)); e->setArgument(7,(v8_LayerStyles)); entity = e; EntityBuffer::Add(this); } +IfcPresentationLayerWithStyle::IfcPresentationLayerWithStyle(IfcAbstractEntity* e) : IfcPresentationLayerAssignment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPresentationLayerWithStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPresentationLayerWithStyle::IfcPresentationLayerWithStyle(std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_AssignedItems, boost::optional< std::string > v4_Identifier, bool v5_LayerOn, bool v6_LayerFrozen, bool v7_LayerBlocked, IfcEntityList::ptr v8_LayerStyles) : IfcPresentationLayerAssignment((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_AssignedItems)); if (v4_Identifier) { e->setArgument(3,(*v4_Identifier)); } else { e->setArgument(3); } e->setArgument(4,(v5_LayerOn)); e->setArgument(5,(v6_LayerFrozen)); e->setArgument(6,(v7_LayerBlocked)); e->setArgument(7,(v8_LayerStyles)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPresentationStyle -bool IfcPresentationStyle::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcPresentationStyle::Name() const { return *entity->getArgument(0); } -void IfcPresentationStyle::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcPresentationStyle::is(Type::Enum v) const { return v == Type::IfcPresentationStyle; } -Type::Enum IfcPresentationStyle::type() const { return Type::IfcPresentationStyle; } +bool IfcPresentationStyle::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcPresentationStyle::Name() const { return *data_->getArgument(0); } +void IfcPresentationStyle::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcPresentationStyle::declaration() const { return *IfcPresentationStyle_type; } Type::Enum IfcPresentationStyle::Class() { return Type::IfcPresentationStyle; } -IfcPresentationStyle::IfcPresentationStyle(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPresentationStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPresentationStyle::IfcPresentationStyle(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } entity = e; EntityBuffer::Add(this); } +IfcPresentationStyle::IfcPresentationStyle(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPresentationStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPresentationStyle::IfcPresentationStyle(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPresentationStyleAssignment -IfcEntityList::ptr IfcPresentationStyleAssignment::Styles() const { return *entity->getArgument(0); } -void IfcPresentationStyleAssignment::setStyles(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcPresentationStyleAssignment::is(Type::Enum v) const { return v == Type::IfcPresentationStyleAssignment; } -Type::Enum IfcPresentationStyleAssignment::type() const { return Type::IfcPresentationStyleAssignment; } +IfcEntityList::ptr IfcPresentationStyleAssignment::Styles() const { return *data_->getArgument(0); } +void IfcPresentationStyleAssignment::setStyles(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcPresentationStyleAssignment::declaration() const { return *IfcPresentationStyleAssignment_type; } Type::Enum IfcPresentationStyleAssignment::Class() { return Type::IfcPresentationStyleAssignment; } -IfcPresentationStyleAssignment::IfcPresentationStyleAssignment(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPresentationStyleAssignment)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPresentationStyleAssignment::IfcPresentationStyleAssignment(IfcEntityList::ptr v1_Styles) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Styles)); entity = e; EntityBuffer::Add(this); } +IfcPresentationStyleAssignment::IfcPresentationStyleAssignment(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPresentationStyleAssignment)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPresentationStyleAssignment::IfcPresentationStyleAssignment(IfcEntityList::ptr v1_Styles) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Styles)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProcedure -std::string IfcProcedure::ProcedureID() const { return *entity->getArgument(5); } -void IfcProcedure::setProcedureID(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcProcedureTypeEnum::IfcProcedureTypeEnum IfcProcedure::ProcedureType() const { return IfcProcedureTypeEnum::FromString(*entity->getArgument(6)); } -void IfcProcedure::setProcedureType(IfcProcedureTypeEnum::IfcProcedureTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcProcedureTypeEnum::ToString(v)); } -bool IfcProcedure::hasUserDefinedProcedureType() const { return !entity->getArgument(7)->isNull(); } -std::string IfcProcedure::UserDefinedProcedureType() const { return *entity->getArgument(7); } -void IfcProcedure::setUserDefinedProcedureType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcProcedure::is(Type::Enum v) const { return v == Type::IfcProcedure || IfcProcess::is(v); } -Type::Enum IfcProcedure::type() const { return Type::IfcProcedure; } +std::string IfcProcedure::ProcedureID() const { return *data_->getArgument(5); } +void IfcProcedure::setProcedureID(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +IfcProcedureTypeEnum::IfcProcedureTypeEnum IfcProcedure::ProcedureType() const { return IfcProcedureTypeEnum::FromString(*data_->getArgument(6)); } +void IfcProcedure::setProcedureType(IfcProcedureTypeEnum::IfcProcedureTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcProcedureTypeEnum::ToString(v)); } +bool IfcProcedure::hasUserDefinedProcedureType() const { return !data_->getArgument(7)->isNull(); } +std::string IfcProcedure::UserDefinedProcedureType() const { return *data_->getArgument(7); } +void IfcProcedure::setUserDefinedProcedureType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcProcedure::declaration() const { return *IfcProcedure_type; } Type::Enum IfcProcedure::Class() { return Type::IfcProcedure; } -IfcProcedure::IfcProcedure(IfcAbstractEntity* e) : IfcProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProcedure)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProcedure::IfcProcedure(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_ProcedureID, IfcProcedureTypeEnum::IfcProcedureTypeEnum v7_ProcedureType, boost::optional< std::string > v8_UserDefinedProcedureType) : IfcProcess((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ProcedureID)); e->setArgument(6,v7_ProcedureType,IfcProcedureTypeEnum::ToString(v7_ProcedureType)); if (v8_UserDefinedProcedureType) { e->setArgument(7,(*v8_UserDefinedProcedureType)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcProcedure::IfcProcedure(IfcAbstractEntity* e) : IfcProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProcedure)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProcedure::IfcProcedure(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_ProcedureID, IfcProcedureTypeEnum::IfcProcedureTypeEnum v7_ProcedureType, boost::optional< std::string > v8_UserDefinedProcedureType) : IfcProcess((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ProcedureID)); e->setArgument(6,v7_ProcedureType,IfcProcedureTypeEnum::ToString(v7_ProcedureType)); if (v8_UserDefinedProcedureType) { e->setArgument(7,(*v8_UserDefinedProcedureType)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProcess -IfcRelAssignsToProcess::list::ptr IfcProcess::OperatesOn() const { return entity->getInverse(Type::IfcRelAssignsToProcess, 6)->as(); } -IfcRelSequence::list::ptr IfcProcess::IsSuccessorFrom() const { return entity->getInverse(Type::IfcRelSequence, 5)->as(); } -IfcRelSequence::list::ptr IfcProcess::IsPredecessorTo() const { return entity->getInverse(Type::IfcRelSequence, 4)->as(); } -bool IfcProcess::is(Type::Enum v) const { return v == Type::IfcProcess || IfcObject::is(v); } -Type::Enum IfcProcess::type() const { return Type::IfcProcess; } + +IfcRelAssignsToProcess::list::ptr IfcProcess::OperatesOn() const { return data_->getInverse(Type::IfcRelAssignsToProcess, 6)->as(); } +IfcRelSequence::list::ptr IfcProcess::IsSuccessorFrom() const { return data_->getInverse(Type::IfcRelSequence, 5)->as(); } +IfcRelSequence::list::ptr IfcProcess::IsPredecessorTo() const { return data_->getInverse(Type::IfcRelSequence, 4)->as(); } + +const IfcParse::entity& IfcProcess::declaration() const { return *IfcProcess_type; } Type::Enum IfcProcess::Class() { return Type::IfcProcess; } -IfcProcess::IfcProcess(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProcess)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProcess::IfcProcess(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcProcess::IfcProcess(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProcess)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProcess::IfcProcess(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProduct -bool IfcProduct::hasObjectPlacement() const { return !entity->getArgument(5)->isNull(); } -IfcObjectPlacement* IfcProduct::ObjectPlacement() const { return (IfcObjectPlacement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcProduct::setObjectPlacement(IfcObjectPlacement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcProduct::hasRepresentation() const { return !entity->getArgument(6)->isNull(); } -IfcProductRepresentation* IfcProduct::Representation() const { return (IfcProductRepresentation*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcProduct::setRepresentation(IfcProductRepresentation* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcRelAssignsToProduct::list::ptr IfcProduct::ReferencedBy() const { return entity->getInverse(Type::IfcRelAssignsToProduct, 6)->as(); } -bool IfcProduct::is(Type::Enum v) const { return v == Type::IfcProduct || IfcObject::is(v); } -Type::Enum IfcProduct::type() const { return Type::IfcProduct; } +bool IfcProduct::hasObjectPlacement() const { return !data_->getArgument(5)->isNull(); } +IfcObjectPlacement* IfcProduct::ObjectPlacement() const { return (IfcObjectPlacement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcProduct::setObjectPlacement(IfcObjectPlacement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcProduct::hasRepresentation() const { return !data_->getArgument(6)->isNull(); } +IfcProductRepresentation* IfcProduct::Representation() const { return (IfcProductRepresentation*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcProduct::setRepresentation(IfcProductRepresentation* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + +IfcRelAssignsToProduct::list::ptr IfcProduct::ReferencedBy() const { return data_->getInverse(Type::IfcRelAssignsToProduct, 6)->as(); } + +const IfcParse::entity& IfcProduct::declaration() const { return *IfcProduct_type; } Type::Enum IfcProduct::Class() { return Type::IfcProduct; } -IfcProduct::IfcProduct(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProduct)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProduct::IfcProduct(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); entity = e; EntityBuffer::Add(this); } +IfcProduct::IfcProduct(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProduct)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProduct::IfcProduct(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProductDefinitionShape -IfcProduct::list::ptr IfcProductDefinitionShape::ShapeOfProduct() const { return entity->getInverse(Type::IfcProduct, 6)->as(); } -IfcShapeAspect::list::ptr IfcProductDefinitionShape::HasShapeAspects() const { return entity->getInverse(Type::IfcShapeAspect, 4)->as(); } -bool IfcProductDefinitionShape::is(Type::Enum v) const { return v == Type::IfcProductDefinitionShape || IfcProductRepresentation::is(v); } -Type::Enum IfcProductDefinitionShape::type() const { return Type::IfcProductDefinitionShape; } + +IfcProduct::list::ptr IfcProductDefinitionShape::ShapeOfProduct() const { return data_->getInverse(Type::IfcProduct, 6)->as(); } +IfcShapeAspect::list::ptr IfcProductDefinitionShape::HasShapeAspects() const { return data_->getInverse(Type::IfcShapeAspect, 4)->as(); } + +const IfcParse::entity& IfcProductDefinitionShape::declaration() const { return *IfcProductDefinitionShape_type; } Type::Enum IfcProductDefinitionShape::Class() { return Type::IfcProductDefinitionShape; } -IfcProductDefinitionShape::IfcProductDefinitionShape(IfcAbstractEntity* e) : IfcProductRepresentation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProductDefinitionShape)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProductDefinitionShape::IfcProductDefinitionShape(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcRepresentation >::ptr v3_Representations) : IfcProductRepresentation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Representations)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcProductDefinitionShape::IfcProductDefinitionShape(IfcAbstractEntity* e) : IfcProductRepresentation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProductDefinitionShape)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProductDefinitionShape::IfcProductDefinitionShape(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcRepresentation >::ptr v3_Representations) : IfcProductRepresentation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Representations)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProductRepresentation -bool IfcProductRepresentation::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcProductRepresentation::Name() const { return *entity->getArgument(0); } -void IfcProductRepresentation::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcProductRepresentation::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcProductRepresentation::Description() const { return *entity->getArgument(1); } -void IfcProductRepresentation::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcTemplatedEntityList< IfcRepresentation >::ptr IfcProductRepresentation::Representations() const { IfcEntityList::ptr es = *entity->getArgument(2); return es->as(); } -void IfcProductRepresentation::setRepresentations(IfcTemplatedEntityList< IfcRepresentation >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v->generalize()); } -bool IfcProductRepresentation::is(Type::Enum v) const { return v == Type::IfcProductRepresentation; } -Type::Enum IfcProductRepresentation::type() const { return Type::IfcProductRepresentation; } +bool IfcProductRepresentation::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcProductRepresentation::Name() const { return *data_->getArgument(0); } +void IfcProductRepresentation::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcProductRepresentation::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcProductRepresentation::Description() const { return *data_->getArgument(1); } +void IfcProductRepresentation::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcTemplatedEntityList< IfcRepresentation >::ptr IfcProductRepresentation::Representations() const { IfcEntityList::ptr es = *data_->getArgument(2); return es->as(); } +void IfcProductRepresentation::setRepresentations(IfcTemplatedEntityList< IfcRepresentation >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v->generalize()); } + + +const IfcParse::entity& IfcProductRepresentation::declaration() const { return *IfcProductRepresentation_type; } Type::Enum IfcProductRepresentation::Class() { return Type::IfcProductRepresentation; } -IfcProductRepresentation::IfcProductRepresentation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcProductRepresentation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProductRepresentation::IfcProductRepresentation(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcRepresentation >::ptr v3_Representations) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Representations)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcProductRepresentation::IfcProductRepresentation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcProductRepresentation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProductRepresentation::IfcProductRepresentation(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcRepresentation >::ptr v3_Representations) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Representations)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProductsOfCombustionProperties -bool IfcProductsOfCombustionProperties::hasSpecificHeatCapacity() const { return !entity->getArgument(1)->isNull(); } -double IfcProductsOfCombustionProperties::SpecificHeatCapacity() const { return *entity->getArgument(1); } -void IfcProductsOfCombustionProperties::setSpecificHeatCapacity(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcProductsOfCombustionProperties::hasN20Content() const { return !entity->getArgument(2)->isNull(); } -double IfcProductsOfCombustionProperties::N20Content() const { return *entity->getArgument(2); } -void IfcProductsOfCombustionProperties::setN20Content(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcProductsOfCombustionProperties::hasCOContent() const { return !entity->getArgument(3)->isNull(); } -double IfcProductsOfCombustionProperties::COContent() const { return *entity->getArgument(3); } -void IfcProductsOfCombustionProperties::setCOContent(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcProductsOfCombustionProperties::hasCO2Content() const { return !entity->getArgument(4)->isNull(); } -double IfcProductsOfCombustionProperties::CO2Content() const { return *entity->getArgument(4); } -void IfcProductsOfCombustionProperties::setCO2Content(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcProductsOfCombustionProperties::is(Type::Enum v) const { return v == Type::IfcProductsOfCombustionProperties || IfcMaterialProperties::is(v); } -Type::Enum IfcProductsOfCombustionProperties::type() const { return Type::IfcProductsOfCombustionProperties; } +bool IfcProductsOfCombustionProperties::hasSpecificHeatCapacity() const { return !data_->getArgument(1)->isNull(); } +double IfcProductsOfCombustionProperties::SpecificHeatCapacity() const { return *data_->getArgument(1); } +void IfcProductsOfCombustionProperties::setSpecificHeatCapacity(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcProductsOfCombustionProperties::hasN20Content() const { return !data_->getArgument(2)->isNull(); } +double IfcProductsOfCombustionProperties::N20Content() const { return *data_->getArgument(2); } +void IfcProductsOfCombustionProperties::setN20Content(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcProductsOfCombustionProperties::hasCOContent() const { return !data_->getArgument(3)->isNull(); } +double IfcProductsOfCombustionProperties::COContent() const { return *data_->getArgument(3); } +void IfcProductsOfCombustionProperties::setCOContent(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcProductsOfCombustionProperties::hasCO2Content() const { return !data_->getArgument(4)->isNull(); } +double IfcProductsOfCombustionProperties::CO2Content() const { return *data_->getArgument(4); } +void IfcProductsOfCombustionProperties::setCO2Content(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcProductsOfCombustionProperties::declaration() const { return *IfcProductsOfCombustionProperties_type; } Type::Enum IfcProductsOfCombustionProperties::Class() { return Type::IfcProductsOfCombustionProperties; } -IfcProductsOfCombustionProperties::IfcProductsOfCombustionProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProductsOfCombustionProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProductsOfCombustionProperties::IfcProductsOfCombustionProperties(IfcMaterial* v1_Material, boost::optional< double > v2_SpecificHeatCapacity, boost::optional< double > v3_N20Content, boost::optional< double > v4_COContent, boost::optional< double > v5_CO2Content) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_SpecificHeatCapacity) { e->setArgument(1,(*v2_SpecificHeatCapacity)); } else { e->setArgument(1); } if (v3_N20Content) { e->setArgument(2,(*v3_N20Content)); } else { e->setArgument(2); } if (v4_COContent) { e->setArgument(3,(*v4_COContent)); } else { e->setArgument(3); } if (v5_CO2Content) { e->setArgument(4,(*v5_CO2Content)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcProductsOfCombustionProperties::IfcProductsOfCombustionProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProductsOfCombustionProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProductsOfCombustionProperties::IfcProductsOfCombustionProperties(IfcMaterial* v1_Material, boost::optional< double > v2_SpecificHeatCapacity, boost::optional< double > v3_N20Content, boost::optional< double > v4_COContent, boost::optional< double > v5_CO2Content) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_SpecificHeatCapacity) { e->setArgument(1,(*v2_SpecificHeatCapacity)); } else { e->setArgument(1); } if (v3_N20Content) { e->setArgument(2,(*v3_N20Content)); } else { e->setArgument(2); } if (v4_COContent) { e->setArgument(3,(*v4_COContent)); } else { e->setArgument(3); } if (v5_CO2Content) { e->setArgument(4,(*v5_CO2Content)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProfileDef -IfcProfileTypeEnum::IfcProfileTypeEnum IfcProfileDef::ProfileType() const { return IfcProfileTypeEnum::FromString(*entity->getArgument(0)); } -void IfcProfileDef::setProfileType(IfcProfileTypeEnum::IfcProfileTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v,IfcProfileTypeEnum::ToString(v)); } -bool IfcProfileDef::hasProfileName() const { return !entity->getArgument(1)->isNull(); } -std::string IfcProfileDef::ProfileName() const { return *entity->getArgument(1); } -void IfcProfileDef::setProfileName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcProfileDef::is(Type::Enum v) const { return v == Type::IfcProfileDef; } -Type::Enum IfcProfileDef::type() const { return Type::IfcProfileDef; } +IfcProfileTypeEnum::IfcProfileTypeEnum IfcProfileDef::ProfileType() const { return IfcProfileTypeEnum::FromString(*data_->getArgument(0)); } +void IfcProfileDef::setProfileType(IfcProfileTypeEnum::IfcProfileTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v,IfcProfileTypeEnum::ToString(v)); } +bool IfcProfileDef::hasProfileName() const { return !data_->getArgument(1)->isNull(); } +std::string IfcProfileDef::ProfileName() const { return *data_->getArgument(1); } +void IfcProfileDef::setProfileName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcProfileDef::declaration() const { return *IfcProfileDef_type; } Type::Enum IfcProfileDef::Class() { return Type::IfcProfileDef; } -IfcProfileDef::IfcProfileDef(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProfileDef::IfcProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } entity = e; EntityBuffer::Add(this); } +IfcProfileDef::IfcProfileDef(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProfileDef::IfcProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProfileProperties -bool IfcProfileProperties::hasProfileName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcProfileProperties::ProfileName() const { return *entity->getArgument(0); } -void IfcProfileProperties::setProfileName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcProfileProperties::hasProfileDefinition() const { return !entity->getArgument(1)->isNull(); } -IfcProfileDef* IfcProfileProperties::ProfileDefinition() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcProfileProperties::setProfileDefinition(IfcProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcProfileProperties::is(Type::Enum v) const { return v == Type::IfcProfileProperties; } -Type::Enum IfcProfileProperties::type() const { return Type::IfcProfileProperties; } +bool IfcProfileProperties::hasProfileName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcProfileProperties::ProfileName() const { return *data_->getArgument(0); } +void IfcProfileProperties::setProfileName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcProfileProperties::hasProfileDefinition() const { return !data_->getArgument(1)->isNull(); } +IfcProfileDef* IfcProfileProperties::ProfileDefinition() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcProfileProperties::setProfileDefinition(IfcProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcProfileProperties::declaration() const { return *IfcProfileProperties_type; } Type::Enum IfcProfileProperties::Class() { return Type::IfcProfileProperties; } -IfcProfileProperties::IfcProfileProperties(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcProfileProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProfileProperties::IfcProfileProperties(boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ProfileName) { e->setArgument(0,(*v1_ProfileName)); } else { e->setArgument(0); } e->setArgument(1,(v2_ProfileDefinition)); entity = e; EntityBuffer::Add(this); } +IfcProfileProperties::IfcProfileProperties(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcProfileProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProfileProperties::IfcProfileProperties(boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ProfileName) { e->setArgument(0,(*v1_ProfileName)); } else { e->setArgument(0); } e->setArgument(1,(v2_ProfileDefinition)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProject -bool IfcProject::hasLongName() const { return !entity->getArgument(5)->isNull(); } -std::string IfcProject::LongName() const { return *entity->getArgument(5); } -void IfcProject::setLongName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcProject::hasPhase() const { return !entity->getArgument(6)->isNull(); } -std::string IfcProject::Phase() const { return *entity->getArgument(6); } -void IfcProject::setPhase(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcTemplatedEntityList< IfcRepresentationContext >::ptr IfcProject::RepresentationContexts() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcProject::setRepresentationContexts(IfcTemplatedEntityList< IfcRepresentationContext >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -IfcUnitAssignment* IfcProject::UnitsInContext() const { return (IfcUnitAssignment*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcProject::setUnitsInContext(IfcUnitAssignment* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcProject::is(Type::Enum v) const { return v == Type::IfcProject || IfcObject::is(v); } -Type::Enum IfcProject::type() const { return Type::IfcProject; } +bool IfcProject::hasLongName() const { return !data_->getArgument(5)->isNull(); } +std::string IfcProject::LongName() const { return *data_->getArgument(5); } +void IfcProject::setLongName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcProject::hasPhase() const { return !data_->getArgument(6)->isNull(); } +std::string IfcProject::Phase() const { return *data_->getArgument(6); } +void IfcProject::setPhase(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +IfcTemplatedEntityList< IfcRepresentationContext >::ptr IfcProject::RepresentationContexts() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcProject::setRepresentationContexts(IfcTemplatedEntityList< IfcRepresentationContext >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } +IfcUnitAssignment* IfcProject::UnitsInContext() const { return (IfcUnitAssignment*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcProject::setUnitsInContext(IfcUnitAssignment* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcProject::declaration() const { return *IfcProject_type; } Type::Enum IfcProject::Class() { return Type::IfcProject; } -IfcProject::IfcProject(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProject)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProject::IfcProject(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_LongName, boost::optional< std::string > v7_Phase, IfcTemplatedEntityList< IfcRepresentationContext >::ptr v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_LongName) { e->setArgument(5,(*v6_LongName)); } else { e->setArgument(5); } if (v7_Phase) { e->setArgument(6,(*v7_Phase)); } else { e->setArgument(6); } e->setArgument(7,(v8_RepresentationContexts)->generalize()); e->setArgument(8,(v9_UnitsInContext)); entity = e; EntityBuffer::Add(this); } +IfcProject::IfcProject(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProject)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProject::IfcProject(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_LongName, boost::optional< std::string > v7_Phase, IfcTemplatedEntityList< IfcRepresentationContext >::ptr v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_LongName) { e->setArgument(5,(*v6_LongName)); } else { e->setArgument(5); } if (v7_Phase) { e->setArgument(6,(*v7_Phase)); } else { e->setArgument(6); } e->setArgument(7,(v8_RepresentationContexts)->generalize()); e->setArgument(8,(v9_UnitsInContext)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProjectOrder -std::string IfcProjectOrder::ID() const { return *entity->getArgument(5); } -void IfcProjectOrder::setID(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum IfcProjectOrder::PredefinedType() const { return IfcProjectOrderTypeEnum::FromString(*entity->getArgument(6)); } -void IfcProjectOrder::setPredefinedType(IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcProjectOrderTypeEnum::ToString(v)); } -bool IfcProjectOrder::hasStatus() const { return !entity->getArgument(7)->isNull(); } -std::string IfcProjectOrder::Status() const { return *entity->getArgument(7); } -void IfcProjectOrder::setStatus(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcProjectOrder::is(Type::Enum v) const { return v == Type::IfcProjectOrder || IfcControl::is(v); } -Type::Enum IfcProjectOrder::type() const { return Type::IfcProjectOrder; } +std::string IfcProjectOrder::ID() const { return *data_->getArgument(5); } +void IfcProjectOrder::setID(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum IfcProjectOrder::PredefinedType() const { return IfcProjectOrderTypeEnum::FromString(*data_->getArgument(6)); } +void IfcProjectOrder::setPredefinedType(IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcProjectOrderTypeEnum::ToString(v)); } +bool IfcProjectOrder::hasStatus() const { return !data_->getArgument(7)->isNull(); } +std::string IfcProjectOrder::Status() const { return *data_->getArgument(7); } +void IfcProjectOrder::setStatus(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcProjectOrder::declaration() const { return *IfcProjectOrder_type; } Type::Enum IfcProjectOrder::Class() { return Type::IfcProjectOrder; } -IfcProjectOrder::IfcProjectOrder(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectOrder)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProjectOrder::IfcProjectOrder(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_ID, IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum v7_PredefinedType, boost::optional< std::string > v8_Status) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ID)); e->setArgument(6,v7_PredefinedType,IfcProjectOrderTypeEnum::ToString(v7_PredefinedType)); if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcProjectOrder::IfcProjectOrder(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectOrder)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProjectOrder::IfcProjectOrder(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_ID, IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum v7_PredefinedType, boost::optional< std::string > v8_Status) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ID)); e->setArgument(6,v7_PredefinedType,IfcProjectOrderTypeEnum::ToString(v7_PredefinedType)); if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProjectOrderRecord -IfcTemplatedEntityList< IfcRelAssignsToProjectOrder >::ptr IfcProjectOrderRecord::Records() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcProjectOrderRecord::setRecords(IfcTemplatedEntityList< IfcRelAssignsToProjectOrder >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v->generalize()); } -IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum IfcProjectOrderRecord::PredefinedType() const { return IfcProjectOrderRecordTypeEnum::FromString(*entity->getArgument(6)); } -void IfcProjectOrderRecord::setPredefinedType(IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcProjectOrderRecordTypeEnum::ToString(v)); } -bool IfcProjectOrderRecord::is(Type::Enum v) const { return v == Type::IfcProjectOrderRecord || IfcControl::is(v); } -Type::Enum IfcProjectOrderRecord::type() const { return Type::IfcProjectOrderRecord; } +IfcTemplatedEntityList< IfcRelAssignsToProjectOrder >::ptr IfcProjectOrderRecord::Records() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcProjectOrderRecord::setRecords(IfcTemplatedEntityList< IfcRelAssignsToProjectOrder >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v->generalize()); } +IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum IfcProjectOrderRecord::PredefinedType() const { return IfcProjectOrderRecordTypeEnum::FromString(*data_->getArgument(6)); } +void IfcProjectOrderRecord::setPredefinedType(IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcProjectOrderRecordTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcProjectOrderRecord::declaration() const { return *IfcProjectOrderRecord_type; } Type::Enum IfcProjectOrderRecord::Class() { return Type::IfcProjectOrderRecord; } -IfcProjectOrderRecord::IfcProjectOrderRecord(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectOrderRecord)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProjectOrderRecord::IfcProjectOrderRecord(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcTemplatedEntityList< IfcRelAssignsToProjectOrder >::ptr v6_Records, IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum v7_PredefinedType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_Records)->generalize()); e->setArgument(6,v7_PredefinedType,IfcProjectOrderRecordTypeEnum::ToString(v7_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcProjectOrderRecord::IfcProjectOrderRecord(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectOrderRecord)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProjectOrderRecord::IfcProjectOrderRecord(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcTemplatedEntityList< IfcRelAssignsToProjectOrder >::ptr v6_Records, IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum v7_PredefinedType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_Records)->generalize()); e->setArgument(6,v7_PredefinedType,IfcProjectOrderRecordTypeEnum::ToString(v7_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProjectionCurve -bool IfcProjectionCurve::is(Type::Enum v) const { return v == Type::IfcProjectionCurve || IfcAnnotationCurveOccurrence::is(v); } -Type::Enum IfcProjectionCurve::type() const { return Type::IfcProjectionCurve; } + + +const IfcParse::entity& IfcProjectionCurve::declaration() const { return *IfcProjectionCurve_type; } Type::Enum IfcProjectionCurve::Class() { return Type::IfcProjectionCurve; } -IfcProjectionCurve::IfcProjectionCurve(IfcAbstractEntity* e) : IfcAnnotationCurveOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectionCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProjectionCurve::IfcProjectionCurve(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationCurveOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcProjectionCurve::IfcProjectionCurve(IfcAbstractEntity* e) : IfcAnnotationCurveOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectionCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProjectionCurve::IfcProjectionCurve(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationCurveOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProjectionElement -bool IfcProjectionElement::is(Type::Enum v) const { return v == Type::IfcProjectionElement || IfcFeatureElementAddition::is(v); } -Type::Enum IfcProjectionElement::type() const { return Type::IfcProjectionElement; } + + +const IfcParse::entity& IfcProjectionElement::declaration() const { return *IfcProjectionElement_type; } Type::Enum IfcProjectionElement::Class() { return Type::IfcProjectionElement; } -IfcProjectionElement::IfcProjectionElement(IfcAbstractEntity* e) : IfcFeatureElementAddition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectionElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProjectionElement::IfcProjectionElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElementAddition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcProjectionElement::IfcProjectionElement(IfcAbstractEntity* e) : IfcFeatureElementAddition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectionElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProjectionElement::IfcProjectionElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElementAddition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProperty -std::string IfcProperty::Name() const { return *entity->getArgument(0); } -void IfcProperty::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcProperty::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcProperty::Description() const { return *entity->getArgument(1); } -void IfcProperty::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcPropertyDependencyRelationship::list::ptr IfcProperty::PropertyForDependance() const { return entity->getInverse(Type::IfcPropertyDependencyRelationship, 0)->as(); } -IfcPropertyDependencyRelationship::list::ptr IfcProperty::PropertyDependsOn() const { return entity->getInverse(Type::IfcPropertyDependencyRelationship, 1)->as(); } -IfcComplexProperty::list::ptr IfcProperty::PartOfComplex() const { return entity->getInverse(Type::IfcComplexProperty, 3)->as(); } -bool IfcProperty::is(Type::Enum v) const { return v == Type::IfcProperty; } -Type::Enum IfcProperty::type() const { return Type::IfcProperty; } +std::string IfcProperty::Name() const { return *data_->getArgument(0); } +void IfcProperty::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcProperty::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcProperty::Description() const { return *data_->getArgument(1); } +void IfcProperty::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + +IfcPropertyDependencyRelationship::list::ptr IfcProperty::PropertyForDependance() const { return data_->getInverse(Type::IfcPropertyDependencyRelationship, 0)->as(); } +IfcPropertyDependencyRelationship::list::ptr IfcProperty::PropertyDependsOn() const { return data_->getInverse(Type::IfcPropertyDependencyRelationship, 1)->as(); } +IfcComplexProperty::list::ptr IfcProperty::PartOfComplex() const { return data_->getInverse(Type::IfcComplexProperty, 3)->as(); } + +const IfcParse::entity& IfcProperty::declaration() const { return *IfcProperty_type; } Type::Enum IfcProperty::Class() { return Type::IfcProperty; } -IfcProperty::IfcProperty(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcProperty)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProperty::IfcProperty(std::string v1_Name, boost::optional< std::string > v2_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } entity = e; EntityBuffer::Add(this); } +IfcProperty::IfcProperty(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcProperty)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProperty::IfcProperty(std::string v1_Name, boost::optional< std::string > v2_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyBoundedValue -bool IfcPropertyBoundedValue::hasUpperBoundValue() const { return !entity->getArgument(2)->isNull(); } -IfcValue* IfcPropertyBoundedValue::UpperBoundValue() const { return (IfcValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcPropertyBoundedValue::setUpperBoundValue(IfcValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPropertyBoundedValue::hasLowerBoundValue() const { return !entity->getArgument(3)->isNull(); } -IfcValue* IfcPropertyBoundedValue::LowerBoundValue() const { return (IfcValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcPropertyBoundedValue::setLowerBoundValue(IfcValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPropertyBoundedValue::hasUnit() const { return !entity->getArgument(4)->isNull(); } -IfcUnit* IfcPropertyBoundedValue::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcPropertyBoundedValue::setUnit(IfcUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcPropertyBoundedValue::is(Type::Enum v) const { return v == Type::IfcPropertyBoundedValue || IfcSimpleProperty::is(v); } -Type::Enum IfcPropertyBoundedValue::type() const { return Type::IfcPropertyBoundedValue; } +bool IfcPropertyBoundedValue::hasUpperBoundValue() const { return !data_->getArgument(2)->isNull(); } +IfcValue* IfcPropertyBoundedValue::UpperBoundValue() const { return (IfcValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcPropertyBoundedValue::setUpperBoundValue(IfcValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcPropertyBoundedValue::hasLowerBoundValue() const { return !data_->getArgument(3)->isNull(); } +IfcValue* IfcPropertyBoundedValue::LowerBoundValue() const { return (IfcValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcPropertyBoundedValue::setLowerBoundValue(IfcValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcPropertyBoundedValue::hasUnit() const { return !data_->getArgument(4)->isNull(); } +IfcUnit* IfcPropertyBoundedValue::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcPropertyBoundedValue::setUnit(IfcUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcPropertyBoundedValue::declaration() const { return *IfcPropertyBoundedValue_type; } Type::Enum IfcPropertyBoundedValue::Class() { return Type::IfcPropertyBoundedValue; } -IfcPropertyBoundedValue::IfcPropertyBoundedValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyBoundedValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyBoundedValue::IfcPropertyBoundedValue(std::string v1_Name, boost::optional< std::string > v2_Description, IfcValue* v3_UpperBoundValue, IfcValue* v4_LowerBoundValue, IfcUnit* v5_Unit) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_UpperBoundValue)); e->setArgument(3,(v4_LowerBoundValue)); e->setArgument(4,(v5_Unit)); entity = e; EntityBuffer::Add(this); } +IfcPropertyBoundedValue::IfcPropertyBoundedValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyBoundedValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyBoundedValue::IfcPropertyBoundedValue(std::string v1_Name, boost::optional< std::string > v2_Description, IfcValue* v3_UpperBoundValue, IfcValue* v4_LowerBoundValue, IfcUnit* v5_Unit) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_UpperBoundValue)); e->setArgument(3,(v4_LowerBoundValue)); e->setArgument(4,(v5_Unit)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyConstraintRelationship -IfcConstraint* IfcPropertyConstraintRelationship::RelatingConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcPropertyConstraintRelationship::setRelatingConstraint(IfcConstraint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcTemplatedEntityList< IfcProperty >::ptr IfcPropertyConstraintRelationship::RelatedProperties() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcPropertyConstraintRelationship::setRelatedProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcPropertyConstraintRelationship::hasName() const { return !entity->getArgument(2)->isNull(); } -std::string IfcPropertyConstraintRelationship::Name() const { return *entity->getArgument(2); } -void IfcPropertyConstraintRelationship::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPropertyConstraintRelationship::hasDescription() const { return !entity->getArgument(3)->isNull(); } -std::string IfcPropertyConstraintRelationship::Description() const { return *entity->getArgument(3); } -void IfcPropertyConstraintRelationship::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPropertyConstraintRelationship::is(Type::Enum v) const { return v == Type::IfcPropertyConstraintRelationship; } -Type::Enum IfcPropertyConstraintRelationship::type() const { return Type::IfcPropertyConstraintRelationship; } +IfcConstraint* IfcPropertyConstraintRelationship::RelatingConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcPropertyConstraintRelationship::setRelatingConstraint(IfcConstraint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcTemplatedEntityList< IfcProperty >::ptr IfcPropertyConstraintRelationship::RelatedProperties() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcPropertyConstraintRelationship::setRelatedProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +bool IfcPropertyConstraintRelationship::hasName() const { return !data_->getArgument(2)->isNull(); } +std::string IfcPropertyConstraintRelationship::Name() const { return *data_->getArgument(2); } +void IfcPropertyConstraintRelationship::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcPropertyConstraintRelationship::hasDescription() const { return !data_->getArgument(3)->isNull(); } +std::string IfcPropertyConstraintRelationship::Description() const { return *data_->getArgument(3); } +void IfcPropertyConstraintRelationship::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcPropertyConstraintRelationship::declaration() const { return *IfcPropertyConstraintRelationship_type; } Type::Enum IfcPropertyConstraintRelationship::Class() { return Type::IfcPropertyConstraintRelationship; } -IfcPropertyConstraintRelationship::IfcPropertyConstraintRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPropertyConstraintRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyConstraintRelationship::IfcPropertyConstraintRelationship(IfcConstraint* v1_RelatingConstraint, IfcTemplatedEntityList< IfcProperty >::ptr v2_RelatedProperties, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelatingConstraint)); e->setArgument(1,(v2_RelatedProperties)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcPropertyConstraintRelationship::IfcPropertyConstraintRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPropertyConstraintRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyConstraintRelationship::IfcPropertyConstraintRelationship(IfcConstraint* v1_RelatingConstraint, IfcTemplatedEntityList< IfcProperty >::ptr v2_RelatedProperties, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelatingConstraint)); e->setArgument(1,(v2_RelatedProperties)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyDefinition -IfcRelAssociates::list::ptr IfcPropertyDefinition::HasAssociations() const { return entity->getInverse(Type::IfcRelAssociates, 4)->as(); } -bool IfcPropertyDefinition::is(Type::Enum v) const { return v == Type::IfcPropertyDefinition || IfcRoot::is(v); } -Type::Enum IfcPropertyDefinition::type() const { return Type::IfcPropertyDefinition; } + +IfcRelAssociates::list::ptr IfcPropertyDefinition::HasAssociations() const { return data_->getInverse(Type::IfcRelAssociates, 4)->as(); } + +const IfcParse::entity& IfcPropertyDefinition::declaration() const { return *IfcPropertyDefinition_type; } Type::Enum IfcPropertyDefinition::Class() { return Type::IfcPropertyDefinition; } -IfcPropertyDefinition::IfcPropertyDefinition(IfcAbstractEntity* e) : IfcRoot((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyDefinition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyDefinition::IfcPropertyDefinition(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRoot((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcPropertyDefinition::IfcPropertyDefinition(IfcAbstractEntity* e) : IfcRoot((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyDefinition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyDefinition::IfcPropertyDefinition(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRoot((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyDependencyRelationship -IfcProperty* IfcPropertyDependencyRelationship::DependingProperty() const { return (IfcProperty*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcPropertyDependencyRelationship::setDependingProperty(IfcProperty* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcProperty* IfcPropertyDependencyRelationship::DependantProperty() const { return (IfcProperty*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcPropertyDependencyRelationship::setDependantProperty(IfcProperty* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcPropertyDependencyRelationship::hasName() const { return !entity->getArgument(2)->isNull(); } -std::string IfcPropertyDependencyRelationship::Name() const { return *entity->getArgument(2); } -void IfcPropertyDependencyRelationship::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPropertyDependencyRelationship::hasDescription() const { return !entity->getArgument(3)->isNull(); } -std::string IfcPropertyDependencyRelationship::Description() const { return *entity->getArgument(3); } -void IfcPropertyDependencyRelationship::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPropertyDependencyRelationship::hasExpression() const { return !entity->getArgument(4)->isNull(); } -std::string IfcPropertyDependencyRelationship::Expression() const { return *entity->getArgument(4); } -void IfcPropertyDependencyRelationship::setExpression(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcPropertyDependencyRelationship::is(Type::Enum v) const { return v == Type::IfcPropertyDependencyRelationship; } -Type::Enum IfcPropertyDependencyRelationship::type() const { return Type::IfcPropertyDependencyRelationship; } +IfcProperty* IfcPropertyDependencyRelationship::DependingProperty() const { return (IfcProperty*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcPropertyDependencyRelationship::setDependingProperty(IfcProperty* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcProperty* IfcPropertyDependencyRelationship::DependantProperty() const { return (IfcProperty*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcPropertyDependencyRelationship::setDependantProperty(IfcProperty* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcPropertyDependencyRelationship::hasName() const { return !data_->getArgument(2)->isNull(); } +std::string IfcPropertyDependencyRelationship::Name() const { return *data_->getArgument(2); } +void IfcPropertyDependencyRelationship::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcPropertyDependencyRelationship::hasDescription() const { return !data_->getArgument(3)->isNull(); } +std::string IfcPropertyDependencyRelationship::Description() const { return *data_->getArgument(3); } +void IfcPropertyDependencyRelationship::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcPropertyDependencyRelationship::hasExpression() const { return !data_->getArgument(4)->isNull(); } +std::string IfcPropertyDependencyRelationship::Expression() const { return *data_->getArgument(4); } +void IfcPropertyDependencyRelationship::setExpression(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcPropertyDependencyRelationship::declaration() const { return *IfcPropertyDependencyRelationship_type; } Type::Enum IfcPropertyDependencyRelationship::Class() { return Type::IfcPropertyDependencyRelationship; } -IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPropertyDependencyRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(IfcProperty* v1_DependingProperty, IfcProperty* v2_DependantProperty, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_Expression) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DependingProperty)); e->setArgument(1,(v2_DependantProperty)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_Expression) { e->setArgument(4,(*v5_Expression)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPropertyDependencyRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(IfcProperty* v1_DependingProperty, IfcProperty* v2_DependantProperty, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_Expression) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DependingProperty)); e->setArgument(1,(v2_DependantProperty)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_Expression) { e->setArgument(4,(*v5_Expression)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyEnumeratedValue -IfcEntityList::ptr IfcPropertyEnumeratedValue::EnumerationValues() const { return *entity->getArgument(2); } -void IfcPropertyEnumeratedValue::setEnumerationValues(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPropertyEnumeratedValue::hasEnumerationReference() const { return !entity->getArgument(3)->isNull(); } -IfcPropertyEnumeration* IfcPropertyEnumeratedValue::EnumerationReference() const { return (IfcPropertyEnumeration*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcPropertyEnumeratedValue::setEnumerationReference(IfcPropertyEnumeration* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPropertyEnumeratedValue::is(Type::Enum v) const { return v == Type::IfcPropertyEnumeratedValue || IfcSimpleProperty::is(v); } -Type::Enum IfcPropertyEnumeratedValue::type() const { return Type::IfcPropertyEnumeratedValue; } +IfcEntityList::ptr IfcPropertyEnumeratedValue::EnumerationValues() const { return *data_->getArgument(2); } +void IfcPropertyEnumeratedValue::setEnumerationValues(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcPropertyEnumeratedValue::hasEnumerationReference() const { return !data_->getArgument(3)->isNull(); } +IfcPropertyEnumeration* IfcPropertyEnumeratedValue::EnumerationReference() const { return (IfcPropertyEnumeration*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcPropertyEnumeratedValue::setEnumerationReference(IfcPropertyEnumeration* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcPropertyEnumeratedValue::declaration() const { return *IfcPropertyEnumeratedValue_type; } Type::Enum IfcPropertyEnumeratedValue::Class() { return Type::IfcPropertyEnumeratedValue; } -IfcPropertyEnumeratedValue::IfcPropertyEnumeratedValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyEnumeratedValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyEnumeratedValue::IfcPropertyEnumeratedValue(std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_EnumerationValues, IfcPropertyEnumeration* v4_EnumerationReference) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_EnumerationValues)); e->setArgument(3,(v4_EnumerationReference)); entity = e; EntityBuffer::Add(this); } +IfcPropertyEnumeratedValue::IfcPropertyEnumeratedValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyEnumeratedValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyEnumeratedValue::IfcPropertyEnumeratedValue(std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_EnumerationValues, IfcPropertyEnumeration* v4_EnumerationReference) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_EnumerationValues)); e->setArgument(3,(v4_EnumerationReference)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyEnumeration -std::string IfcPropertyEnumeration::Name() const { return *entity->getArgument(0); } -void IfcPropertyEnumeration::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcEntityList::ptr IfcPropertyEnumeration::EnumerationValues() const { return *entity->getArgument(1); } -void IfcPropertyEnumeration::setEnumerationValues(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcPropertyEnumeration::hasUnit() const { return !entity->getArgument(2)->isNull(); } -IfcUnit* IfcPropertyEnumeration::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcPropertyEnumeration::setUnit(IfcUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPropertyEnumeration::is(Type::Enum v) const { return v == Type::IfcPropertyEnumeration; } -Type::Enum IfcPropertyEnumeration::type() const { return Type::IfcPropertyEnumeration; } +std::string IfcPropertyEnumeration::Name() const { return *data_->getArgument(0); } +void IfcPropertyEnumeration::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcEntityList::ptr IfcPropertyEnumeration::EnumerationValues() const { return *data_->getArgument(1); } +void IfcPropertyEnumeration::setEnumerationValues(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcPropertyEnumeration::hasUnit() const { return !data_->getArgument(2)->isNull(); } +IfcUnit* IfcPropertyEnumeration::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcPropertyEnumeration::setUnit(IfcUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcPropertyEnumeration::declaration() const { return *IfcPropertyEnumeration_type; } Type::Enum IfcPropertyEnumeration::Class() { return Type::IfcPropertyEnumeration; } -IfcPropertyEnumeration::IfcPropertyEnumeration(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPropertyEnumeration)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyEnumeration::IfcPropertyEnumeration(std::string v1_Name, IfcEntityList::ptr v2_EnumerationValues, IfcUnit* v3_Unit) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); e->setArgument(1,(v2_EnumerationValues)); e->setArgument(2,(v3_Unit)); entity = e; EntityBuffer::Add(this); } +IfcPropertyEnumeration::IfcPropertyEnumeration(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPropertyEnumeration)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyEnumeration::IfcPropertyEnumeration(std::string v1_Name, IfcEntityList::ptr v2_EnumerationValues, IfcUnit* v3_Unit) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); e->setArgument(1,(v2_EnumerationValues)); e->setArgument(2,(v3_Unit)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyListValue -IfcEntityList::ptr IfcPropertyListValue::ListValues() const { return *entity->getArgument(2); } -void IfcPropertyListValue::setListValues(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPropertyListValue::hasUnit() const { return !entity->getArgument(3)->isNull(); } -IfcUnit* IfcPropertyListValue::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcPropertyListValue::setUnit(IfcUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPropertyListValue::is(Type::Enum v) const { return v == Type::IfcPropertyListValue || IfcSimpleProperty::is(v); } -Type::Enum IfcPropertyListValue::type() const { return Type::IfcPropertyListValue; } +IfcEntityList::ptr IfcPropertyListValue::ListValues() const { return *data_->getArgument(2); } +void IfcPropertyListValue::setListValues(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcPropertyListValue::hasUnit() const { return !data_->getArgument(3)->isNull(); } +IfcUnit* IfcPropertyListValue::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcPropertyListValue::setUnit(IfcUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcPropertyListValue::declaration() const { return *IfcPropertyListValue_type; } Type::Enum IfcPropertyListValue::Class() { return Type::IfcPropertyListValue; } -IfcPropertyListValue::IfcPropertyListValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyListValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyListValue::IfcPropertyListValue(std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_ListValues, IfcUnit* v4_Unit) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_ListValues)); e->setArgument(3,(v4_Unit)); entity = e; EntityBuffer::Add(this); } +IfcPropertyListValue::IfcPropertyListValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyListValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyListValue::IfcPropertyListValue(std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_ListValues, IfcUnit* v4_Unit) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_ListValues)); e->setArgument(3,(v4_Unit)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyReferenceValue -bool IfcPropertyReferenceValue::hasUsageName() const { return !entity->getArgument(2)->isNull(); } -std::string IfcPropertyReferenceValue::UsageName() const { return *entity->getArgument(2); } -void IfcPropertyReferenceValue::setUsageName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcObjectReferenceSelect* IfcPropertyReferenceValue::PropertyReference() const { return (IfcObjectReferenceSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcPropertyReferenceValue::setPropertyReference(IfcObjectReferenceSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPropertyReferenceValue::is(Type::Enum v) const { return v == Type::IfcPropertyReferenceValue || IfcSimpleProperty::is(v); } -Type::Enum IfcPropertyReferenceValue::type() const { return Type::IfcPropertyReferenceValue; } +bool IfcPropertyReferenceValue::hasUsageName() const { return !data_->getArgument(2)->isNull(); } +std::string IfcPropertyReferenceValue::UsageName() const { return *data_->getArgument(2); } +void IfcPropertyReferenceValue::setUsageName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcObjectReferenceSelect* IfcPropertyReferenceValue::PropertyReference() const { return (IfcObjectReferenceSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcPropertyReferenceValue::setPropertyReference(IfcObjectReferenceSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcPropertyReferenceValue::declaration() const { return *IfcPropertyReferenceValue_type; } Type::Enum IfcPropertyReferenceValue::Class() { return Type::IfcPropertyReferenceValue; } -IfcPropertyReferenceValue::IfcPropertyReferenceValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyReferenceValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyReferenceValue::IfcPropertyReferenceValue(std::string v1_Name, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UsageName, IfcObjectReferenceSelect* v4_PropertyReference) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } if (v3_UsageName) { e->setArgument(2,(*v3_UsageName)); } else { e->setArgument(2); } e->setArgument(3,(v4_PropertyReference)); entity = e; EntityBuffer::Add(this); } +IfcPropertyReferenceValue::IfcPropertyReferenceValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyReferenceValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyReferenceValue::IfcPropertyReferenceValue(std::string v1_Name, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UsageName, IfcObjectReferenceSelect* v4_PropertyReference) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } if (v3_UsageName) { e->setArgument(2,(*v3_UsageName)); } else { e->setArgument(2); } e->setArgument(3,(v4_PropertyReference)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertySet -IfcTemplatedEntityList< IfcProperty >::ptr IfcPropertySet::HasProperties() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcPropertySet::setHasProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -bool IfcPropertySet::is(Type::Enum v) const { return v == Type::IfcPropertySet || IfcPropertySetDefinition::is(v); } -Type::Enum IfcPropertySet::type() const { return Type::IfcPropertySet; } +IfcTemplatedEntityList< IfcProperty >::ptr IfcPropertySet::HasProperties() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcPropertySet::setHasProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } + + +const IfcParse::entity& IfcPropertySet::declaration() const { return *IfcPropertySet_type; } Type::Enum IfcPropertySet::Class() { return Type::IfcPropertySet; } -IfcPropertySet::IfcPropertySet(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertySet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertySet::IfcPropertySet(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcProperty >::ptr v5_HasProperties) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_HasProperties)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcPropertySet::IfcPropertySet(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertySet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertySet::IfcPropertySet(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcProperty >::ptr v5_HasProperties) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_HasProperties)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertySetDefinition -IfcRelDefinesByProperties::list::ptr IfcPropertySetDefinition::PropertyDefinitionOf() const { return entity->getInverse(Type::IfcRelDefinesByProperties, 5)->as(); } -IfcTypeObject::list::ptr IfcPropertySetDefinition::DefinesType() const { return entity->getInverse(Type::IfcTypeObject, 5)->as(); } -bool IfcPropertySetDefinition::is(Type::Enum v) const { return v == Type::IfcPropertySetDefinition || IfcPropertyDefinition::is(v); } -Type::Enum IfcPropertySetDefinition::type() const { return Type::IfcPropertySetDefinition; } + +IfcRelDefinesByProperties::list::ptr IfcPropertySetDefinition::PropertyDefinitionOf() const { return data_->getInverse(Type::IfcRelDefinesByProperties, 5)->as(); } +IfcTypeObject::list::ptr IfcPropertySetDefinition::DefinesType() const { return data_->getInverse(Type::IfcTypeObject, 5)->as(); } + +const IfcParse::entity& IfcPropertySetDefinition::declaration() const { return *IfcPropertySetDefinition_type; } Type::Enum IfcPropertySetDefinition::Class() { return Type::IfcPropertySetDefinition; } -IfcPropertySetDefinition::IfcPropertySetDefinition(IfcAbstractEntity* e) : IfcPropertyDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertySetDefinition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertySetDefinition::IfcPropertySetDefinition(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcPropertyDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcPropertySetDefinition::IfcPropertySetDefinition(IfcAbstractEntity* e) : IfcPropertyDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertySetDefinition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertySetDefinition::IfcPropertySetDefinition(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcPropertyDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertySingleValue -bool IfcPropertySingleValue::hasNominalValue() const { return !entity->getArgument(2)->isNull(); } -IfcValue* IfcPropertySingleValue::NominalValue() const { return (IfcValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcPropertySingleValue::setNominalValue(IfcValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcPropertySingleValue::hasUnit() const { return !entity->getArgument(3)->isNull(); } -IfcUnit* IfcPropertySingleValue::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcPropertySingleValue::setUnit(IfcUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPropertySingleValue::is(Type::Enum v) const { return v == Type::IfcPropertySingleValue || IfcSimpleProperty::is(v); } -Type::Enum IfcPropertySingleValue::type() const { return Type::IfcPropertySingleValue; } +bool IfcPropertySingleValue::hasNominalValue() const { return !data_->getArgument(2)->isNull(); } +IfcValue* IfcPropertySingleValue::NominalValue() const { return (IfcValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcPropertySingleValue::setNominalValue(IfcValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcPropertySingleValue::hasUnit() const { return !data_->getArgument(3)->isNull(); } +IfcUnit* IfcPropertySingleValue::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcPropertySingleValue::setUnit(IfcUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcPropertySingleValue::declaration() const { return *IfcPropertySingleValue_type; } Type::Enum IfcPropertySingleValue::Class() { return Type::IfcPropertySingleValue; } -IfcPropertySingleValue::IfcPropertySingleValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertySingleValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertySingleValue::IfcPropertySingleValue(std::string v1_Name, boost::optional< std::string > v2_Description, IfcValue* v3_NominalValue, IfcUnit* v4_Unit) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_NominalValue)); e->setArgument(3,(v4_Unit)); entity = e; EntityBuffer::Add(this); } +IfcPropertySingleValue::IfcPropertySingleValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertySingleValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertySingleValue::IfcPropertySingleValue(std::string v1_Name, boost::optional< std::string > v2_Description, IfcValue* v3_NominalValue, IfcUnit* v4_Unit) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_NominalValue)); e->setArgument(3,(v4_Unit)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyTableValue -IfcEntityList::ptr IfcPropertyTableValue::DefiningValues() const { return *entity->getArgument(2); } -void IfcPropertyTableValue::setDefiningValues(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcEntityList::ptr IfcPropertyTableValue::DefinedValues() const { return *entity->getArgument(3); } -void IfcPropertyTableValue::setDefinedValues(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcPropertyTableValue::hasExpression() const { return !entity->getArgument(4)->isNull(); } -std::string IfcPropertyTableValue::Expression() const { return *entity->getArgument(4); } -void IfcPropertyTableValue::setExpression(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcPropertyTableValue::hasDefiningUnit() const { return !entity->getArgument(5)->isNull(); } -IfcUnit* IfcPropertyTableValue::DefiningUnit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcPropertyTableValue::setDefiningUnit(IfcUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcPropertyTableValue::hasDefinedUnit() const { return !entity->getArgument(6)->isNull(); } -IfcUnit* IfcPropertyTableValue::DefinedUnit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcPropertyTableValue::setDefinedUnit(IfcUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcPropertyTableValue::is(Type::Enum v) const { return v == Type::IfcPropertyTableValue || IfcSimpleProperty::is(v); } -Type::Enum IfcPropertyTableValue::type() const { return Type::IfcPropertyTableValue; } +IfcEntityList::ptr IfcPropertyTableValue::DefiningValues() const { return *data_->getArgument(2); } +void IfcPropertyTableValue::setDefiningValues(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcEntityList::ptr IfcPropertyTableValue::DefinedValues() const { return *data_->getArgument(3); } +void IfcPropertyTableValue::setDefinedValues(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcPropertyTableValue::hasExpression() const { return !data_->getArgument(4)->isNull(); } +std::string IfcPropertyTableValue::Expression() const { return *data_->getArgument(4); } +void IfcPropertyTableValue::setExpression(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcPropertyTableValue::hasDefiningUnit() const { return !data_->getArgument(5)->isNull(); } +IfcUnit* IfcPropertyTableValue::DefiningUnit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcPropertyTableValue::setDefiningUnit(IfcUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcPropertyTableValue::hasDefinedUnit() const { return !data_->getArgument(6)->isNull(); } +IfcUnit* IfcPropertyTableValue::DefinedUnit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcPropertyTableValue::setDefinedUnit(IfcUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcPropertyTableValue::declaration() const { return *IfcPropertyTableValue_type; } Type::Enum IfcPropertyTableValue::Class() { return Type::IfcPropertyTableValue; } -IfcPropertyTableValue::IfcPropertyTableValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyTableValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyTableValue::IfcPropertyTableValue(std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_DefiningValues, IfcEntityList::ptr v4_DefinedValues, boost::optional< std::string > v5_Expression, IfcUnit* v6_DefiningUnit, IfcUnit* v7_DefinedUnit) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_DefiningValues)); e->setArgument(3,(v4_DefinedValues)); if (v5_Expression) { e->setArgument(4,(*v5_Expression)); } else { e->setArgument(4); } e->setArgument(5,(v6_DefiningUnit)); e->setArgument(6,(v7_DefinedUnit)); entity = e; EntityBuffer::Add(this); } +IfcPropertyTableValue::IfcPropertyTableValue(IfcAbstractEntity* e) : IfcSimpleProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyTableValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyTableValue::IfcPropertyTableValue(std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_DefiningValues, IfcEntityList::ptr v4_DefinedValues, boost::optional< std::string > v5_Expression, IfcUnit* v6_DefiningUnit, IfcUnit* v7_DefinedUnit) : IfcSimpleProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_DefiningValues)); e->setArgument(3,(v4_DefinedValues)); if (v5_Expression) { e->setArgument(4,(*v5_Expression)); } else { e->setArgument(4); } e->setArgument(5,(v6_DefiningUnit)); e->setArgument(6,(v7_DefinedUnit)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProtectiveDeviceType -IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum IfcProtectiveDeviceType::PredefinedType() const { return IfcProtectiveDeviceTypeEnum::FromString(*entity->getArgument(9)); } -void IfcProtectiveDeviceType::setPredefinedType(IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcProtectiveDeviceTypeEnum::ToString(v)); } -bool IfcProtectiveDeviceType::is(Type::Enum v) const { return v == Type::IfcProtectiveDeviceType || IfcFlowControllerType::is(v); } -Type::Enum IfcProtectiveDeviceType::type() const { return Type::IfcProtectiveDeviceType; } +IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum IfcProtectiveDeviceType::PredefinedType() const { return IfcProtectiveDeviceTypeEnum::FromString(*data_->getArgument(9)); } +void IfcProtectiveDeviceType::setPredefinedType(IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcProtectiveDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcProtectiveDeviceType::declaration() const { return *IfcProtectiveDeviceType_type; } Type::Enum IfcProtectiveDeviceType::Class() { return Type::IfcProtectiveDeviceType; } -IfcProtectiveDeviceType::IfcProtectiveDeviceType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProtectiveDeviceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProtectiveDeviceType::IfcProtectiveDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcProtectiveDeviceTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcProtectiveDeviceType::IfcProtectiveDeviceType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProtectiveDeviceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProtectiveDeviceType::IfcProtectiveDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcProtectiveDeviceTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProxy -IfcObjectTypeEnum::IfcObjectTypeEnum IfcProxy::ProxyType() const { return IfcObjectTypeEnum::FromString(*entity->getArgument(7)); } -void IfcProxy::setProxyType(IfcObjectTypeEnum::IfcObjectTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcObjectTypeEnum::ToString(v)); } -bool IfcProxy::hasTag() const { return !entity->getArgument(8)->isNull(); } -std::string IfcProxy::Tag() const { return *entity->getArgument(8); } -void IfcProxy::setTag(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcProxy::is(Type::Enum v) const { return v == Type::IfcProxy || IfcProduct::is(v); } -Type::Enum IfcProxy::type() const { return Type::IfcProxy; } +IfcObjectTypeEnum::IfcObjectTypeEnum IfcProxy::ProxyType() const { return IfcObjectTypeEnum::FromString(*data_->getArgument(7)); } +void IfcProxy::setProxyType(IfcObjectTypeEnum::IfcObjectTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcObjectTypeEnum::ToString(v)); } +bool IfcProxy::hasTag() const { return !data_->getArgument(8)->isNull(); } +std::string IfcProxy::Tag() const { return *data_->getArgument(8); } +void IfcProxy::setTag(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcProxy::declaration() const { return *IfcProxy_type; } Type::Enum IfcProxy::Class() { return Type::IfcProxy; } -IfcProxy::IfcProxy(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProxy)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProxy::IfcProxy(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcObjectTypeEnum::IfcObjectTypeEnum v8_ProxyType, boost::optional< std::string > v9_Tag) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,v8_ProxyType,IfcObjectTypeEnum::ToString(v8_ProxyType)); if (v9_Tag) { e->setArgument(8,(*v9_Tag)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcProxy::IfcProxy(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProxy)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProxy::IfcProxy(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcObjectTypeEnum::IfcObjectTypeEnum v8_ProxyType, boost::optional< std::string > v9_Tag) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,v8_ProxyType,IfcObjectTypeEnum::ToString(v8_ProxyType)); if (v9_Tag) { e->setArgument(8,(*v9_Tag)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPumpType -IfcPumpTypeEnum::IfcPumpTypeEnum IfcPumpType::PredefinedType() const { return IfcPumpTypeEnum::FromString(*entity->getArgument(9)); } -void IfcPumpType::setPredefinedType(IfcPumpTypeEnum::IfcPumpTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcPumpTypeEnum::ToString(v)); } -bool IfcPumpType::is(Type::Enum v) const { return v == Type::IfcPumpType || IfcFlowMovingDeviceType::is(v); } -Type::Enum IfcPumpType::type() const { return Type::IfcPumpType; } +IfcPumpTypeEnum::IfcPumpTypeEnum IfcPumpType::PredefinedType() const { return IfcPumpTypeEnum::FromString(*data_->getArgument(9)); } +void IfcPumpType::setPredefinedType(IfcPumpTypeEnum::IfcPumpTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcPumpTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcPumpType::declaration() const { return *IfcPumpType_type; } Type::Enum IfcPumpType::Class() { return Type::IfcPumpType; } -IfcPumpType::IfcPumpType(IfcAbstractEntity* e) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPumpType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPumpType::IfcPumpType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPumpTypeEnum::IfcPumpTypeEnum v10_PredefinedType) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcPumpTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcPumpType::IfcPumpType(IfcAbstractEntity* e) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPumpType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPumpType::IfcPumpType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPumpTypeEnum::IfcPumpTypeEnum v10_PredefinedType) : IfcFlowMovingDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcPumpTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcQuantityArea -double IfcQuantityArea::AreaValue() const { return *entity->getArgument(3); } -void IfcQuantityArea::setAreaValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcQuantityArea::is(Type::Enum v) const { return v == Type::IfcQuantityArea || IfcPhysicalSimpleQuantity::is(v); } -Type::Enum IfcQuantityArea::type() const { return Type::IfcQuantityArea; } +double IfcQuantityArea::AreaValue() const { return *data_->getArgument(3); } +void IfcQuantityArea::setAreaValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcQuantityArea::declaration() const { return *IfcQuantityArea_type; } Type::Enum IfcQuantityArea::Class() { return Type::IfcQuantityArea; } -IfcQuantityArea::IfcQuantityArea(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityArea)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcQuantityArea::IfcQuantityArea(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_AreaValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_AreaValue)); entity = e; EntityBuffer::Add(this); } +IfcQuantityArea::IfcQuantityArea(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityArea)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcQuantityArea::IfcQuantityArea(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_AreaValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_AreaValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcQuantityCount -double IfcQuantityCount::CountValue() const { return *entity->getArgument(3); } -void IfcQuantityCount::setCountValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcQuantityCount::is(Type::Enum v) const { return v == Type::IfcQuantityCount || IfcPhysicalSimpleQuantity::is(v); } -Type::Enum IfcQuantityCount::type() const { return Type::IfcQuantityCount; } +double IfcQuantityCount::CountValue() const { return *data_->getArgument(3); } +void IfcQuantityCount::setCountValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcQuantityCount::declaration() const { return *IfcQuantityCount_type; } Type::Enum IfcQuantityCount::Class() { return Type::IfcQuantityCount; } -IfcQuantityCount::IfcQuantityCount(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityCount)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcQuantityCount::IfcQuantityCount(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_CountValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_CountValue)); entity = e; EntityBuffer::Add(this); } +IfcQuantityCount::IfcQuantityCount(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityCount)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcQuantityCount::IfcQuantityCount(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_CountValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_CountValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcQuantityLength -double IfcQuantityLength::LengthValue() const { return *entity->getArgument(3); } -void IfcQuantityLength::setLengthValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcQuantityLength::is(Type::Enum v) const { return v == Type::IfcQuantityLength || IfcPhysicalSimpleQuantity::is(v); } -Type::Enum IfcQuantityLength::type() const { return Type::IfcQuantityLength; } +double IfcQuantityLength::LengthValue() const { return *data_->getArgument(3); } +void IfcQuantityLength::setLengthValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcQuantityLength::declaration() const { return *IfcQuantityLength_type; } Type::Enum IfcQuantityLength::Class() { return Type::IfcQuantityLength; } -IfcQuantityLength::IfcQuantityLength(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityLength)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcQuantityLength::IfcQuantityLength(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_LengthValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_LengthValue)); entity = e; EntityBuffer::Add(this); } +IfcQuantityLength::IfcQuantityLength(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityLength)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcQuantityLength::IfcQuantityLength(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_LengthValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_LengthValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcQuantityTime -double IfcQuantityTime::TimeValue() const { return *entity->getArgument(3); } -void IfcQuantityTime::setTimeValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcQuantityTime::is(Type::Enum v) const { return v == Type::IfcQuantityTime || IfcPhysicalSimpleQuantity::is(v); } -Type::Enum IfcQuantityTime::type() const { return Type::IfcQuantityTime; } +double IfcQuantityTime::TimeValue() const { return *data_->getArgument(3); } +void IfcQuantityTime::setTimeValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcQuantityTime::declaration() const { return *IfcQuantityTime_type; } Type::Enum IfcQuantityTime::Class() { return Type::IfcQuantityTime; } -IfcQuantityTime::IfcQuantityTime(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityTime)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcQuantityTime::IfcQuantityTime(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_TimeValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_TimeValue)); entity = e; EntityBuffer::Add(this); } +IfcQuantityTime::IfcQuantityTime(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityTime)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcQuantityTime::IfcQuantityTime(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_TimeValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_TimeValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcQuantityVolume -double IfcQuantityVolume::VolumeValue() const { return *entity->getArgument(3); } -void IfcQuantityVolume::setVolumeValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcQuantityVolume::is(Type::Enum v) const { return v == Type::IfcQuantityVolume || IfcPhysicalSimpleQuantity::is(v); } -Type::Enum IfcQuantityVolume::type() const { return Type::IfcQuantityVolume; } +double IfcQuantityVolume::VolumeValue() const { return *data_->getArgument(3); } +void IfcQuantityVolume::setVolumeValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcQuantityVolume::declaration() const { return *IfcQuantityVolume_type; } Type::Enum IfcQuantityVolume::Class() { return Type::IfcQuantityVolume; } -IfcQuantityVolume::IfcQuantityVolume(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityVolume)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcQuantityVolume::IfcQuantityVolume(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_VolumeValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_VolumeValue)); entity = e; EntityBuffer::Add(this); } +IfcQuantityVolume::IfcQuantityVolume(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityVolume)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcQuantityVolume::IfcQuantityVolume(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_VolumeValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_VolumeValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcQuantityWeight -double IfcQuantityWeight::WeightValue() const { return *entity->getArgument(3); } -void IfcQuantityWeight::setWeightValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcQuantityWeight::is(Type::Enum v) const { return v == Type::IfcQuantityWeight || IfcPhysicalSimpleQuantity::is(v); } -Type::Enum IfcQuantityWeight::type() const { return Type::IfcQuantityWeight; } +double IfcQuantityWeight::WeightValue() const { return *data_->getArgument(3); } +void IfcQuantityWeight::setWeightValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcQuantityWeight::declaration() const { return *IfcQuantityWeight_type; } Type::Enum IfcQuantityWeight::Class() { return Type::IfcQuantityWeight; } -IfcQuantityWeight::IfcQuantityWeight(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityWeight)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcQuantityWeight::IfcQuantityWeight(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_WeightValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_WeightValue)); entity = e; EntityBuffer::Add(this); } +IfcQuantityWeight::IfcQuantityWeight(IfcAbstractEntity* e) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantityWeight)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcQuantityWeight::IfcQuantityWeight(std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_WeightValue) : IfcPhysicalSimpleQuantity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_Unit)); e->setArgument(3,(v4_WeightValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRadiusDimension -bool IfcRadiusDimension::is(Type::Enum v) const { return v == Type::IfcRadiusDimension || IfcDimensionCurveDirectedCallout::is(v); } -Type::Enum IfcRadiusDimension::type() const { return Type::IfcRadiusDimension; } + + +const IfcParse::entity& IfcRadiusDimension::declaration() const { return *IfcRadiusDimension_type; } Type::Enum IfcRadiusDimension::Class() { return Type::IfcRadiusDimension; } -IfcRadiusDimension::IfcRadiusDimension(IfcAbstractEntity* e) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRadiusDimension)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRadiusDimension::IfcRadiusDimension(IfcEntityList::ptr v1_Contents) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); entity = e; EntityBuffer::Add(this); } +IfcRadiusDimension::IfcRadiusDimension(IfcAbstractEntity* e) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRadiusDimension)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRadiusDimension::IfcRadiusDimension(IfcEntityList::ptr v1_Contents) : IfcDimensionCurveDirectedCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRailing -bool IfcRailing::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcRailingTypeEnum::IfcRailingTypeEnum IfcRailing::PredefinedType() const { return IfcRailingTypeEnum::FromString(*entity->getArgument(8)); } -void IfcRailing::setPredefinedType(IfcRailingTypeEnum::IfcRailingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcRailingTypeEnum::ToString(v)); } -bool IfcRailing::is(Type::Enum v) const { return v == Type::IfcRailing || IfcBuildingElement::is(v); } -Type::Enum IfcRailing::type() const { return Type::IfcRailing; } +bool IfcRailing::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcRailingTypeEnum::IfcRailingTypeEnum IfcRailing::PredefinedType() const { return IfcRailingTypeEnum::FromString(*data_->getArgument(8)); } +void IfcRailing::setPredefinedType(IfcRailingTypeEnum::IfcRailingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcRailingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcRailing::declaration() const { return *IfcRailing_type; } Type::Enum IfcRailing::Class() { return Type::IfcRailing; } -IfcRailing::IfcRailing(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRailing)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRailing::IfcRailing(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcRailingTypeEnum::IfcRailingTypeEnum > v9_PredefinedType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcRailingTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcRailing::IfcRailing(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRailing)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRailing::IfcRailing(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcRailingTypeEnum::IfcRailingTypeEnum > v9_PredefinedType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcRailingTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRailingType -IfcRailingTypeEnum::IfcRailingTypeEnum IfcRailingType::PredefinedType() const { return IfcRailingTypeEnum::FromString(*entity->getArgument(9)); } -void IfcRailingType::setPredefinedType(IfcRailingTypeEnum::IfcRailingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcRailingTypeEnum::ToString(v)); } -bool IfcRailingType::is(Type::Enum v) const { return v == Type::IfcRailingType || IfcBuildingElementType::is(v); } -Type::Enum IfcRailingType::type() const { return Type::IfcRailingType; } +IfcRailingTypeEnum::IfcRailingTypeEnum IfcRailingType::PredefinedType() const { return IfcRailingTypeEnum::FromString(*data_->getArgument(9)); } +void IfcRailingType::setPredefinedType(IfcRailingTypeEnum::IfcRailingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcRailingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcRailingType::declaration() const { return *IfcRailingType_type; } Type::Enum IfcRailingType::Class() { return Type::IfcRailingType; } -IfcRailingType::IfcRailingType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRailingType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRailingType::IfcRailingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRailingTypeEnum::IfcRailingTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcRailingTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcRailingType::IfcRailingType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRailingType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRailingType::IfcRailingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRailingTypeEnum::IfcRailingTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcRailingTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRamp -IfcRampTypeEnum::IfcRampTypeEnum IfcRamp::ShapeType() const { return IfcRampTypeEnum::FromString(*entity->getArgument(8)); } -void IfcRamp::setShapeType(IfcRampTypeEnum::IfcRampTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcRampTypeEnum::ToString(v)); } -bool IfcRamp::is(Type::Enum v) const { return v == Type::IfcRamp || IfcBuildingElement::is(v); } -Type::Enum IfcRamp::type() const { return Type::IfcRamp; } +IfcRampTypeEnum::IfcRampTypeEnum IfcRamp::ShapeType() const { return IfcRampTypeEnum::FromString(*data_->getArgument(8)); } +void IfcRamp::setShapeType(IfcRampTypeEnum::IfcRampTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcRampTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcRamp::declaration() const { return *IfcRamp_type; } Type::Enum IfcRamp::Class() { return Type::IfcRamp; } -IfcRamp::IfcRamp(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRamp)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRamp::IfcRamp(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcRampTypeEnum::IfcRampTypeEnum v9_ShapeType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_ShapeType,IfcRampTypeEnum::ToString(v9_ShapeType)); entity = e; EntityBuffer::Add(this); } +IfcRamp::IfcRamp(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRamp)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRamp::IfcRamp(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcRampTypeEnum::IfcRampTypeEnum v9_ShapeType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_ShapeType,IfcRampTypeEnum::ToString(v9_ShapeType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRampFlight -bool IfcRampFlight::is(Type::Enum v) const { return v == Type::IfcRampFlight || IfcBuildingElement::is(v); } -Type::Enum IfcRampFlight::type() const { return Type::IfcRampFlight; } + + +const IfcParse::entity& IfcRampFlight::declaration() const { return *IfcRampFlight_type; } Type::Enum IfcRampFlight::Class() { return Type::IfcRampFlight; } -IfcRampFlight::IfcRampFlight(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRampFlight)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRampFlight::IfcRampFlight(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcRampFlight::IfcRampFlight(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRampFlight)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRampFlight::IfcRampFlight(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRampFlightType -IfcRampFlightTypeEnum::IfcRampFlightTypeEnum IfcRampFlightType::PredefinedType() const { return IfcRampFlightTypeEnum::FromString(*entity->getArgument(9)); } -void IfcRampFlightType::setPredefinedType(IfcRampFlightTypeEnum::IfcRampFlightTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcRampFlightTypeEnum::ToString(v)); } -bool IfcRampFlightType::is(Type::Enum v) const { return v == Type::IfcRampFlightType || IfcBuildingElementType::is(v); } -Type::Enum IfcRampFlightType::type() const { return Type::IfcRampFlightType; } +IfcRampFlightTypeEnum::IfcRampFlightTypeEnum IfcRampFlightType::PredefinedType() const { return IfcRampFlightTypeEnum::FromString(*data_->getArgument(9)); } +void IfcRampFlightType::setPredefinedType(IfcRampFlightTypeEnum::IfcRampFlightTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcRampFlightTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcRampFlightType::declaration() const { return *IfcRampFlightType_type; } Type::Enum IfcRampFlightType::Class() { return Type::IfcRampFlightType; } -IfcRampFlightType::IfcRampFlightType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRampFlightType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRampFlightType::IfcRampFlightType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRampFlightTypeEnum::IfcRampFlightTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcRampFlightTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcRampFlightType::IfcRampFlightType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRampFlightType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRampFlightType::IfcRampFlightType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRampFlightTypeEnum::IfcRampFlightTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcRampFlightTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRationalBezierCurve -std::vector< double > /*[2:?]*/ IfcRationalBezierCurve::WeightsData() const { return *entity->getArgument(5); } -void IfcRationalBezierCurve::setWeightsData(std::vector< double > /*[2:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRationalBezierCurve::is(Type::Enum v) const { return v == Type::IfcRationalBezierCurve || IfcBezierCurve::is(v); } -Type::Enum IfcRationalBezierCurve::type() const { return Type::IfcRationalBezierCurve; } +std::vector< double > /*[2:?]*/ IfcRationalBezierCurve::WeightsData() const { return *data_->getArgument(5); } +void IfcRationalBezierCurve::setWeightsData(std::vector< double > /*[2:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRationalBezierCurve::declaration() const { return *IfcRationalBezierCurve_type; } Type::Enum IfcRationalBezierCurve::Class() { return Type::IfcRationalBezierCurve; } -IfcRationalBezierCurve::IfcRationalBezierCurve(IfcAbstractEntity* e) : IfcBezierCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRationalBezierCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRationalBezierCurve::IfcRationalBezierCurve(int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect, std::vector< double > /*[2:?]*/ v6_WeightsData) : IfcBezierCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Degree)); e->setArgument(1,(v2_ControlPointsList)->generalize()); e->setArgument(2,v3_CurveForm,IfcBSplineCurveForm::ToString(v3_CurveForm)); e->setArgument(3,(v4_ClosedCurve)); e->setArgument(4,(v5_SelfIntersect)); e->setArgument(5,(v6_WeightsData)); entity = e; EntityBuffer::Add(this); } +IfcRationalBezierCurve::IfcRationalBezierCurve(IfcAbstractEntity* e) : IfcBezierCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRationalBezierCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRationalBezierCurve::IfcRationalBezierCurve(int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect, std::vector< double > /*[2:?]*/ v6_WeightsData) : IfcBezierCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Degree)); e->setArgument(1,(v2_ControlPointsList)->generalize()); e->setArgument(2,v3_CurveForm,IfcBSplineCurveForm::ToString(v3_CurveForm)); e->setArgument(3,(v4_ClosedCurve)); e->setArgument(4,(v5_SelfIntersect)); e->setArgument(5,(v6_WeightsData)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRectangleHollowProfileDef -double IfcRectangleHollowProfileDef::WallThickness() const { return *entity->getArgument(5); } -void IfcRectangleHollowProfileDef::setWallThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRectangleHollowProfileDef::hasInnerFilletRadius() const { return !entity->getArgument(6)->isNull(); } -double IfcRectangleHollowProfileDef::InnerFilletRadius() const { return *entity->getArgument(6); } -void IfcRectangleHollowProfileDef::setInnerFilletRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRectangleHollowProfileDef::hasOuterFilletRadius() const { return !entity->getArgument(7)->isNull(); } -double IfcRectangleHollowProfileDef::OuterFilletRadius() const { return *entity->getArgument(7); } -void IfcRectangleHollowProfileDef::setOuterFilletRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcRectangleHollowProfileDef::is(Type::Enum v) const { return v == Type::IfcRectangleHollowProfileDef || IfcRectangleProfileDef::is(v); } -Type::Enum IfcRectangleHollowProfileDef::type() const { return Type::IfcRectangleHollowProfileDef; } +double IfcRectangleHollowProfileDef::WallThickness() const { return *data_->getArgument(5); } +void IfcRectangleHollowProfileDef::setWallThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcRectangleHollowProfileDef::hasInnerFilletRadius() const { return !data_->getArgument(6)->isNull(); } +double IfcRectangleHollowProfileDef::InnerFilletRadius() const { return *data_->getArgument(6); } +void IfcRectangleHollowProfileDef::setInnerFilletRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcRectangleHollowProfileDef::hasOuterFilletRadius() const { return !data_->getArgument(7)->isNull(); } +double IfcRectangleHollowProfileDef::OuterFilletRadius() const { return *data_->getArgument(7); } +void IfcRectangleHollowProfileDef::setOuterFilletRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcRectangleHollowProfileDef::declaration() const { return *IfcRectangleHollowProfileDef_type; } Type::Enum IfcRectangleHollowProfileDef::Class() { return Type::IfcRectangleHollowProfileDef; } -IfcRectangleHollowProfileDef::IfcRectangleHollowProfileDef(IfcAbstractEntity* e) : IfcRectangleProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRectangleHollowProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRectangleHollowProfileDef::IfcRectangleHollowProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim, double v6_WallThickness, boost::optional< double > v7_InnerFilletRadius, boost::optional< double > v8_OuterFilletRadius) : IfcRectangleProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_XDim)); e->setArgument(4,(v5_YDim)); e->setArgument(5,(v6_WallThickness)); if (v7_InnerFilletRadius) { e->setArgument(6,(*v7_InnerFilletRadius)); } else { e->setArgument(6); } if (v8_OuterFilletRadius) { e->setArgument(7,(*v8_OuterFilletRadius)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcRectangleHollowProfileDef::IfcRectangleHollowProfileDef(IfcAbstractEntity* e) : IfcRectangleProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRectangleHollowProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRectangleHollowProfileDef::IfcRectangleHollowProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim, double v6_WallThickness, boost::optional< double > v7_InnerFilletRadius, boost::optional< double > v8_OuterFilletRadius) : IfcRectangleProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_XDim)); e->setArgument(4,(v5_YDim)); e->setArgument(5,(v6_WallThickness)); if (v7_InnerFilletRadius) { e->setArgument(6,(*v7_InnerFilletRadius)); } else { e->setArgument(6); } if (v8_OuterFilletRadius) { e->setArgument(7,(*v8_OuterFilletRadius)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRectangleProfileDef -double IfcRectangleProfileDef::XDim() const { return *entity->getArgument(3); } -void IfcRectangleProfileDef::setXDim(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcRectangleProfileDef::YDim() const { return *entity->getArgument(4); } -void IfcRectangleProfileDef::setYDim(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcRectangleProfileDef::is(Type::Enum v) const { return v == Type::IfcRectangleProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcRectangleProfileDef::type() const { return Type::IfcRectangleProfileDef; } +double IfcRectangleProfileDef::XDim() const { return *data_->getArgument(3); } +void IfcRectangleProfileDef::setXDim(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcRectangleProfileDef::YDim() const { return *data_->getArgument(4); } +void IfcRectangleProfileDef::setYDim(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcRectangleProfileDef::declaration() const { return *IfcRectangleProfileDef_type; } Type::Enum IfcRectangleProfileDef::Class() { return Type::IfcRectangleProfileDef; } -IfcRectangleProfileDef::IfcRectangleProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRectangleProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRectangleProfileDef::IfcRectangleProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_XDim)); e->setArgument(4,(v5_YDim)); entity = e; EntityBuffer::Add(this); } +IfcRectangleProfileDef::IfcRectangleProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRectangleProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRectangleProfileDef::IfcRectangleProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_XDim)); e->setArgument(4,(v5_YDim)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRectangularPyramid -double IfcRectangularPyramid::XLength() const { return *entity->getArgument(1); } -void IfcRectangularPyramid::setXLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcRectangularPyramid::YLength() const { return *entity->getArgument(2); } -void IfcRectangularPyramid::setYLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -double IfcRectangularPyramid::Height() const { return *entity->getArgument(3); } -void IfcRectangularPyramid::setHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcRectangularPyramid::is(Type::Enum v) const { return v == Type::IfcRectangularPyramid || IfcCsgPrimitive3D::is(v); } -Type::Enum IfcRectangularPyramid::type() const { return Type::IfcRectangularPyramid; } +double IfcRectangularPyramid::XLength() const { return *data_->getArgument(1); } +void IfcRectangularPyramid::setXLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcRectangularPyramid::YLength() const { return *data_->getArgument(2); } +void IfcRectangularPyramid::setYLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +double IfcRectangularPyramid::Height() const { return *data_->getArgument(3); } +void IfcRectangularPyramid::setHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcRectangularPyramid::declaration() const { return *IfcRectangularPyramid_type; } Type::Enum IfcRectangularPyramid::Class() { return Type::IfcRectangularPyramid; } -IfcRectangularPyramid::IfcRectangularPyramid(IfcAbstractEntity* e) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRectangularPyramid)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRectangularPyramid::IfcRectangularPyramid(IfcAxis2Placement3D* v1_Position, double v2_XLength, double v3_YLength, double v4_Height) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_XLength)); e->setArgument(2,(v3_YLength)); e->setArgument(3,(v4_Height)); entity = e; EntityBuffer::Add(this); } +IfcRectangularPyramid::IfcRectangularPyramid(IfcAbstractEntity* e) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRectangularPyramid)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRectangularPyramid::IfcRectangularPyramid(IfcAxis2Placement3D* v1_Position, double v2_XLength, double v3_YLength, double v4_Height) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_XLength)); e->setArgument(2,(v3_YLength)); e->setArgument(3,(v4_Height)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRectangularTrimmedSurface -IfcSurface* IfcRectangularTrimmedSurface::BasisSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcRectangularTrimmedSurface::setBasisSurface(IfcSurface* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcRectangularTrimmedSurface::U1() const { return *entity->getArgument(1); } -void IfcRectangularTrimmedSurface::setU1(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcRectangularTrimmedSurface::V1() const { return *entity->getArgument(2); } -void IfcRectangularTrimmedSurface::setV1(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -double IfcRectangularTrimmedSurface::U2() const { return *entity->getArgument(3); } -void IfcRectangularTrimmedSurface::setU2(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcRectangularTrimmedSurface::V2() const { return *entity->getArgument(4); } -void IfcRectangularTrimmedSurface::setV2(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcRectangularTrimmedSurface::Usense() const { return *entity->getArgument(5); } -void IfcRectangularTrimmedSurface::setUsense(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRectangularTrimmedSurface::Vsense() const { return *entity->getArgument(6); } -void IfcRectangularTrimmedSurface::setVsense(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRectangularTrimmedSurface::is(Type::Enum v) const { return v == Type::IfcRectangularTrimmedSurface || IfcBoundedSurface::is(v); } -Type::Enum IfcRectangularTrimmedSurface::type() const { return Type::IfcRectangularTrimmedSurface; } +IfcSurface* IfcRectangularTrimmedSurface::BasisSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcRectangularTrimmedSurface::setBasisSurface(IfcSurface* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcRectangularTrimmedSurface::U1() const { return *data_->getArgument(1); } +void IfcRectangularTrimmedSurface::setU1(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcRectangularTrimmedSurface::V1() const { return *data_->getArgument(2); } +void IfcRectangularTrimmedSurface::setV1(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +double IfcRectangularTrimmedSurface::U2() const { return *data_->getArgument(3); } +void IfcRectangularTrimmedSurface::setU2(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcRectangularTrimmedSurface::V2() const { return *data_->getArgument(4); } +void IfcRectangularTrimmedSurface::setV2(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcRectangularTrimmedSurface::Usense() const { return *data_->getArgument(5); } +void IfcRectangularTrimmedSurface::setUsense(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcRectangularTrimmedSurface::Vsense() const { return *data_->getArgument(6); } +void IfcRectangularTrimmedSurface::setVsense(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcRectangularTrimmedSurface::declaration() const { return *IfcRectangularTrimmedSurface_type; } Type::Enum IfcRectangularTrimmedSurface::Class() { return Type::IfcRectangularTrimmedSurface; } -IfcRectangularTrimmedSurface::IfcRectangularTrimmedSurface(IfcAbstractEntity* e) : IfcBoundedSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRectangularTrimmedSurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRectangularTrimmedSurface::IfcRectangularTrimmedSurface(IfcSurface* v1_BasisSurface, double v2_U1, double v3_V1, double v4_U2, double v5_V2, bool v6_Usense, bool v7_Vsense) : IfcBoundedSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisSurface)); e->setArgument(1,(v2_U1)); e->setArgument(2,(v3_V1)); e->setArgument(3,(v4_U2)); e->setArgument(4,(v5_V2)); e->setArgument(5,(v6_Usense)); e->setArgument(6,(v7_Vsense)); entity = e; EntityBuffer::Add(this); } +IfcRectangularTrimmedSurface::IfcRectangularTrimmedSurface(IfcAbstractEntity* e) : IfcBoundedSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRectangularTrimmedSurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRectangularTrimmedSurface::IfcRectangularTrimmedSurface(IfcSurface* v1_BasisSurface, double v2_U1, double v3_V1, double v4_U2, double v5_V2, bool v6_Usense, bool v7_Vsense) : IfcBoundedSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisSurface)); e->setArgument(1,(v2_U1)); e->setArgument(2,(v3_V1)); e->setArgument(3,(v4_U2)); e->setArgument(4,(v5_V2)); e->setArgument(5,(v6_Usense)); e->setArgument(6,(v7_Vsense)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcReferencesValueDocument -IfcDocumentSelect* IfcReferencesValueDocument::ReferencedDocument() const { return (IfcDocumentSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcReferencesValueDocument::setReferencedDocument(IfcDocumentSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcTemplatedEntityList< IfcAppliedValue >::ptr IfcReferencesValueDocument::ReferencingValues() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcReferencesValueDocument::setReferencingValues(IfcTemplatedEntityList< IfcAppliedValue >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcReferencesValueDocument::hasName() const { return !entity->getArgument(2)->isNull(); } -std::string IfcReferencesValueDocument::Name() const { return *entity->getArgument(2); } -void IfcReferencesValueDocument::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcReferencesValueDocument::hasDescription() const { return !entity->getArgument(3)->isNull(); } -std::string IfcReferencesValueDocument::Description() const { return *entity->getArgument(3); } -void IfcReferencesValueDocument::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcReferencesValueDocument::is(Type::Enum v) const { return v == Type::IfcReferencesValueDocument; } -Type::Enum IfcReferencesValueDocument::type() const { return Type::IfcReferencesValueDocument; } +IfcDocumentSelect* IfcReferencesValueDocument::ReferencedDocument() const { return (IfcDocumentSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcReferencesValueDocument::setReferencedDocument(IfcDocumentSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcTemplatedEntityList< IfcAppliedValue >::ptr IfcReferencesValueDocument::ReferencingValues() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcReferencesValueDocument::setReferencingValues(IfcTemplatedEntityList< IfcAppliedValue >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +bool IfcReferencesValueDocument::hasName() const { return !data_->getArgument(2)->isNull(); } +std::string IfcReferencesValueDocument::Name() const { return *data_->getArgument(2); } +void IfcReferencesValueDocument::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcReferencesValueDocument::hasDescription() const { return !data_->getArgument(3)->isNull(); } +std::string IfcReferencesValueDocument::Description() const { return *data_->getArgument(3); } +void IfcReferencesValueDocument::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcReferencesValueDocument::declaration() const { return *IfcReferencesValueDocument_type; } Type::Enum IfcReferencesValueDocument::Class() { return Type::IfcReferencesValueDocument; } -IfcReferencesValueDocument::IfcReferencesValueDocument(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcReferencesValueDocument)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcReferencesValueDocument::IfcReferencesValueDocument(IfcDocumentSelect* v1_ReferencedDocument, IfcTemplatedEntityList< IfcAppliedValue >::ptr v2_ReferencingValues, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ReferencedDocument)); e->setArgument(1,(v2_ReferencingValues)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcReferencesValueDocument::IfcReferencesValueDocument(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcReferencesValueDocument)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcReferencesValueDocument::IfcReferencesValueDocument(IfcDocumentSelect* v1_ReferencedDocument, IfcTemplatedEntityList< IfcAppliedValue >::ptr v2_ReferencingValues, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ReferencedDocument)); e->setArgument(1,(v2_ReferencingValues)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRegularTimeSeries -double IfcRegularTimeSeries::TimeStep() const { return *entity->getArgument(8); } -void IfcRegularTimeSeries::setTimeStep(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -IfcTemplatedEntityList< IfcTimeSeriesValue >::ptr IfcRegularTimeSeries::Values() const { IfcEntityList::ptr es = *entity->getArgument(9); return es->as(); } -void IfcRegularTimeSeries::setValues(IfcTemplatedEntityList< IfcTimeSeriesValue >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v->generalize()); } -bool IfcRegularTimeSeries::is(Type::Enum v) const { return v == Type::IfcRegularTimeSeries || IfcTimeSeries::is(v); } -Type::Enum IfcRegularTimeSeries::type() const { return Type::IfcRegularTimeSeries; } +double IfcRegularTimeSeries::TimeStep() const { return *data_->getArgument(8); } +void IfcRegularTimeSeries::setTimeStep(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +IfcTemplatedEntityList< IfcTimeSeriesValue >::ptr IfcRegularTimeSeries::Values() const { IfcEntityList::ptr es = *data_->getArgument(9); return es->as(); } +void IfcRegularTimeSeries::setValues(IfcTemplatedEntityList< IfcTimeSeriesValue >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v->generalize()); } + + +const IfcParse::entity& IfcRegularTimeSeries::declaration() const { return *IfcRegularTimeSeries_type; } Type::Enum IfcRegularTimeSeries::Class() { return Type::IfcRegularTimeSeries; } -IfcRegularTimeSeries::IfcRegularTimeSeries(IfcAbstractEntity* e) : IfcTimeSeries((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRegularTimeSeries)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRegularTimeSeries::IfcRegularTimeSeries(std::string v1_Name, boost::optional< std::string > v2_Description, IfcDateTimeSelect* v3_StartTime, IfcDateTimeSelect* v4_EndTime, IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v5_TimeSeriesDataType, IfcDataOriginEnum::IfcDataOriginEnum v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, IfcUnit* v8_Unit, double v9_TimeStep, IfcTemplatedEntityList< IfcTimeSeriesValue >::ptr v10_Values) : IfcTimeSeries((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_StartTime)); e->setArgument(3,(v4_EndTime)); e->setArgument(4,v5_TimeSeriesDataType,IfcTimeSeriesDataTypeEnum::ToString(v5_TimeSeriesDataType)); e->setArgument(5,v6_DataOrigin,IfcDataOriginEnum::ToString(v6_DataOrigin)); if (v7_UserDefinedDataOrigin) { e->setArgument(6,(*v7_UserDefinedDataOrigin)); } else { e->setArgument(6); } e->setArgument(7,(v8_Unit)); e->setArgument(8,(v9_TimeStep)); e->setArgument(9,(v10_Values)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcRegularTimeSeries::IfcRegularTimeSeries(IfcAbstractEntity* e) : IfcTimeSeries((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRegularTimeSeries)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRegularTimeSeries::IfcRegularTimeSeries(std::string v1_Name, boost::optional< std::string > v2_Description, IfcDateTimeSelect* v3_StartTime, IfcDateTimeSelect* v4_EndTime, IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v5_TimeSeriesDataType, IfcDataOriginEnum::IfcDataOriginEnum v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, IfcUnit* v8_Unit, double v9_TimeStep, IfcTemplatedEntityList< IfcTimeSeriesValue >::ptr v10_Values) : IfcTimeSeries((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_StartTime)); e->setArgument(3,(v4_EndTime)); e->setArgument(4,v5_TimeSeriesDataType,IfcTimeSeriesDataTypeEnum::ToString(v5_TimeSeriesDataType)); e->setArgument(5,v6_DataOrigin,IfcDataOriginEnum::ToString(v6_DataOrigin)); if (v7_UserDefinedDataOrigin) { e->setArgument(6,(*v7_UserDefinedDataOrigin)); } else { e->setArgument(6); } e->setArgument(7,(v8_Unit)); e->setArgument(8,(v9_TimeStep)); e->setArgument(9,(v10_Values)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcReinforcementBarProperties -double IfcReinforcementBarProperties::TotalCrossSectionArea() const { return *entity->getArgument(0); } -void IfcReinforcementBarProperties::setTotalCrossSectionArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -std::string IfcReinforcementBarProperties::SteelGrade() const { return *entity->getArgument(1); } -void IfcReinforcementBarProperties::setSteelGrade(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcReinforcementBarProperties::hasBarSurface() const { return !entity->getArgument(2)->isNull(); } -IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcementBarProperties::BarSurface() const { return IfcReinforcingBarSurfaceEnum::FromString(*entity->getArgument(2)); } -void IfcReinforcementBarProperties::setBarSurface(IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v,IfcReinforcingBarSurfaceEnum::ToString(v)); } -bool IfcReinforcementBarProperties::hasEffectiveDepth() const { return !entity->getArgument(3)->isNull(); } -double IfcReinforcementBarProperties::EffectiveDepth() const { return *entity->getArgument(3); } -void IfcReinforcementBarProperties::setEffectiveDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcReinforcementBarProperties::hasNominalBarDiameter() const { return !entity->getArgument(4)->isNull(); } -double IfcReinforcementBarProperties::NominalBarDiameter() const { return *entity->getArgument(4); } -void IfcReinforcementBarProperties::setNominalBarDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcReinforcementBarProperties::hasBarCount() const { return !entity->getArgument(5)->isNull(); } -double IfcReinforcementBarProperties::BarCount() const { return *entity->getArgument(5); } -void IfcReinforcementBarProperties::setBarCount(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcReinforcementBarProperties::is(Type::Enum v) const { return v == Type::IfcReinforcementBarProperties; } -Type::Enum IfcReinforcementBarProperties::type() const { return Type::IfcReinforcementBarProperties; } +double IfcReinforcementBarProperties::TotalCrossSectionArea() const { return *data_->getArgument(0); } +void IfcReinforcementBarProperties::setTotalCrossSectionArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +std::string IfcReinforcementBarProperties::SteelGrade() const { return *data_->getArgument(1); } +void IfcReinforcementBarProperties::setSteelGrade(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcReinforcementBarProperties::hasBarSurface() const { return !data_->getArgument(2)->isNull(); } +IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcementBarProperties::BarSurface() const { return IfcReinforcingBarSurfaceEnum::FromString(*data_->getArgument(2)); } +void IfcReinforcementBarProperties::setBarSurface(IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v,IfcReinforcingBarSurfaceEnum::ToString(v)); } +bool IfcReinforcementBarProperties::hasEffectiveDepth() const { return !data_->getArgument(3)->isNull(); } +double IfcReinforcementBarProperties::EffectiveDepth() const { return *data_->getArgument(3); } +void IfcReinforcementBarProperties::setEffectiveDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcReinforcementBarProperties::hasNominalBarDiameter() const { return !data_->getArgument(4)->isNull(); } +double IfcReinforcementBarProperties::NominalBarDiameter() const { return *data_->getArgument(4); } +void IfcReinforcementBarProperties::setNominalBarDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcReinforcementBarProperties::hasBarCount() const { return !data_->getArgument(5)->isNull(); } +double IfcReinforcementBarProperties::BarCount() const { return *data_->getArgument(5); } +void IfcReinforcementBarProperties::setBarCount(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcReinforcementBarProperties::declaration() const { return *IfcReinforcementBarProperties_type; } Type::Enum IfcReinforcementBarProperties::Class() { return Type::IfcReinforcementBarProperties; } -IfcReinforcementBarProperties::IfcReinforcementBarProperties(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcReinforcementBarProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcReinforcementBarProperties::IfcReinforcementBarProperties(double v1_TotalCrossSectionArea, std::string v2_SteelGrade, boost::optional< IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum > v3_BarSurface, boost::optional< double > v4_EffectiveDepth, boost::optional< double > v5_NominalBarDiameter, boost::optional< double > v6_BarCount) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TotalCrossSectionArea)); e->setArgument(1,(v2_SteelGrade)); if (v3_BarSurface) { e->setArgument(2,*v3_BarSurface,IfcReinforcingBarSurfaceEnum::ToString(*v3_BarSurface)); } else { e->setArgument(2); } if (v4_EffectiveDepth) { e->setArgument(3,(*v4_EffectiveDepth)); } else { e->setArgument(3); } if (v5_NominalBarDiameter) { e->setArgument(4,(*v5_NominalBarDiameter)); } else { e->setArgument(4); } if (v6_BarCount) { e->setArgument(5,(*v6_BarCount)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcReinforcementBarProperties::IfcReinforcementBarProperties(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcReinforcementBarProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcReinforcementBarProperties::IfcReinforcementBarProperties(double v1_TotalCrossSectionArea, std::string v2_SteelGrade, boost::optional< IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum > v3_BarSurface, boost::optional< double > v4_EffectiveDepth, boost::optional< double > v5_NominalBarDiameter, boost::optional< double > v6_BarCount) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TotalCrossSectionArea)); e->setArgument(1,(v2_SteelGrade)); if (v3_BarSurface) { e->setArgument(2,*v3_BarSurface,IfcReinforcingBarSurfaceEnum::ToString(*v3_BarSurface)); } else { e->setArgument(2); } if (v4_EffectiveDepth) { e->setArgument(3,(*v4_EffectiveDepth)); } else { e->setArgument(3); } if (v5_NominalBarDiameter) { e->setArgument(4,(*v5_NominalBarDiameter)); } else { e->setArgument(4); } if (v6_BarCount) { e->setArgument(5,(*v6_BarCount)); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcReinforcementDefinitionProperties -bool IfcReinforcementDefinitionProperties::hasDefinitionType() const { return !entity->getArgument(4)->isNull(); } -std::string IfcReinforcementDefinitionProperties::DefinitionType() const { return *entity->getArgument(4); } -void IfcReinforcementDefinitionProperties::setDefinitionType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcTemplatedEntityList< IfcSectionReinforcementProperties >::ptr IfcReinforcementDefinitionProperties::ReinforcementSectionDefinitions() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcReinforcementDefinitionProperties::setReinforcementSectionDefinitions(IfcTemplatedEntityList< IfcSectionReinforcementProperties >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v->generalize()); } -bool IfcReinforcementDefinitionProperties::is(Type::Enum v) const { return v == Type::IfcReinforcementDefinitionProperties || IfcPropertySetDefinition::is(v); } -Type::Enum IfcReinforcementDefinitionProperties::type() const { return Type::IfcReinforcementDefinitionProperties; } +bool IfcReinforcementDefinitionProperties::hasDefinitionType() const { return !data_->getArgument(4)->isNull(); } +std::string IfcReinforcementDefinitionProperties::DefinitionType() const { return *data_->getArgument(4); } +void IfcReinforcementDefinitionProperties::setDefinitionType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcTemplatedEntityList< IfcSectionReinforcementProperties >::ptr IfcReinforcementDefinitionProperties::ReinforcementSectionDefinitions() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcReinforcementDefinitionProperties::setReinforcementSectionDefinitions(IfcTemplatedEntityList< IfcSectionReinforcementProperties >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v->generalize()); } + + +const IfcParse::entity& IfcReinforcementDefinitionProperties::declaration() const { return *IfcReinforcementDefinitionProperties_type; } Type::Enum IfcReinforcementDefinitionProperties::Class() { return Type::IfcReinforcementDefinitionProperties; } -IfcReinforcementDefinitionProperties::IfcReinforcementDefinitionProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcementDefinitionProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcReinforcementDefinitionProperties::IfcReinforcementDefinitionProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_DefinitionType, IfcTemplatedEntityList< IfcSectionReinforcementProperties >::ptr v6_ReinforcementSectionDefinitions) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_DefinitionType) { e->setArgument(4,(*v5_DefinitionType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ReinforcementSectionDefinitions)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcReinforcementDefinitionProperties::IfcReinforcementDefinitionProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcementDefinitionProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcReinforcementDefinitionProperties::IfcReinforcementDefinitionProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_DefinitionType, IfcTemplatedEntityList< IfcSectionReinforcementProperties >::ptr v6_ReinforcementSectionDefinitions) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_DefinitionType) { e->setArgument(4,(*v5_DefinitionType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ReinforcementSectionDefinitions)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcReinforcingBar -double IfcReinforcingBar::NominalDiameter() const { return *entity->getArgument(9); } -void IfcReinforcingBar::setNominalDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -double IfcReinforcingBar::CrossSectionArea() const { return *entity->getArgument(10); } -void IfcReinforcingBar::setCrossSectionArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcReinforcingBar::hasBarLength() const { return !entity->getArgument(11)->isNull(); } -double IfcReinforcingBar::BarLength() const { return *entity->getArgument(11); } -void IfcReinforcingBar::setBarLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum IfcReinforcingBar::BarRole() const { return IfcReinforcingBarRoleEnum::FromString(*entity->getArgument(12)); } -void IfcReinforcingBar::setBarRole(IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v,IfcReinforcingBarRoleEnum::ToString(v)); } -bool IfcReinforcingBar::hasBarSurface() const { return !entity->getArgument(13)->isNull(); } -IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcingBar::BarSurface() const { return IfcReinforcingBarSurfaceEnum::FromString(*entity->getArgument(13)); } -void IfcReinforcingBar::setBarSurface(IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v,IfcReinforcingBarSurfaceEnum::ToString(v)); } -bool IfcReinforcingBar::is(Type::Enum v) const { return v == Type::IfcReinforcingBar || IfcReinforcingElement::is(v); } -Type::Enum IfcReinforcingBar::type() const { return Type::IfcReinforcingBar; } +double IfcReinforcingBar::NominalDiameter() const { return *data_->getArgument(9); } +void IfcReinforcingBar::setNominalDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +double IfcReinforcingBar::CrossSectionArea() const { return *data_->getArgument(10); } +void IfcReinforcingBar::setCrossSectionArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcReinforcingBar::hasBarLength() const { return !data_->getArgument(11)->isNull(); } +double IfcReinforcingBar::BarLength() const { return *data_->getArgument(11); } +void IfcReinforcingBar::setBarLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum IfcReinforcingBar::BarRole() const { return IfcReinforcingBarRoleEnum::FromString(*data_->getArgument(12)); } +void IfcReinforcingBar::setBarRole(IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v,IfcReinforcingBarRoleEnum::ToString(v)); } +bool IfcReinforcingBar::hasBarSurface() const { return !data_->getArgument(13)->isNull(); } +IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcingBar::BarSurface() const { return IfcReinforcingBarSurfaceEnum::FromString(*data_->getArgument(13)); } +void IfcReinforcingBar::setBarSurface(IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v,IfcReinforcingBarSurfaceEnum::ToString(v)); } + + +const IfcParse::entity& IfcReinforcingBar::declaration() const { return *IfcReinforcingBar_type; } Type::Enum IfcReinforcingBar::Class() { return Type::IfcReinforcingBar; } -IfcReinforcingBar::IfcReinforcingBar(IfcAbstractEntity* e) : IfcReinforcingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingBar)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcReinforcingBar::IfcReinforcingBar(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, double v10_NominalDiameter, double v11_CrossSectionArea, boost::optional< double > v12_BarLength, IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum v13_BarRole, boost::optional< IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum > v14_BarSurface) : IfcReinforcingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } e->setArgument(9,(v10_NominalDiameter)); e->setArgument(10,(v11_CrossSectionArea)); if (v12_BarLength) { e->setArgument(11,(*v12_BarLength)); } else { e->setArgument(11); } e->setArgument(12,v13_BarRole,IfcReinforcingBarRoleEnum::ToString(v13_BarRole)); if (v14_BarSurface) { e->setArgument(13,*v14_BarSurface,IfcReinforcingBarSurfaceEnum::ToString(*v14_BarSurface)); } else { e->setArgument(13); } entity = e; EntityBuffer::Add(this); } +IfcReinforcingBar::IfcReinforcingBar(IfcAbstractEntity* e) : IfcReinforcingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingBar)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcReinforcingBar::IfcReinforcingBar(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, double v10_NominalDiameter, double v11_CrossSectionArea, boost::optional< double > v12_BarLength, IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum v13_BarRole, boost::optional< IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum > v14_BarSurface) : IfcReinforcingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } e->setArgument(9,(v10_NominalDiameter)); e->setArgument(10,(v11_CrossSectionArea)); if (v12_BarLength) { e->setArgument(11,(*v12_BarLength)); } else { e->setArgument(11); } e->setArgument(12,v13_BarRole,IfcReinforcingBarRoleEnum::ToString(v13_BarRole)); if (v14_BarSurface) { e->setArgument(13,*v14_BarSurface,IfcReinforcingBarSurfaceEnum::ToString(*v14_BarSurface)); } else { e->setArgument(13); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcReinforcingElement -bool IfcReinforcingElement::hasSteelGrade() const { return !entity->getArgument(8)->isNull(); } -std::string IfcReinforcingElement::SteelGrade() const { return *entity->getArgument(8); } -void IfcReinforcingElement::setSteelGrade(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcReinforcingElement::is(Type::Enum v) const { return v == Type::IfcReinforcingElement || IfcBuildingElementComponent::is(v); } -Type::Enum IfcReinforcingElement::type() const { return Type::IfcReinforcingElement; } +bool IfcReinforcingElement::hasSteelGrade() const { return !data_->getArgument(8)->isNull(); } +std::string IfcReinforcingElement::SteelGrade() const { return *data_->getArgument(8); } +void IfcReinforcingElement::setSteelGrade(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcReinforcingElement::declaration() const { return *IfcReinforcingElement_type; } Type::Enum IfcReinforcingElement::Class() { return Type::IfcReinforcingElement; } -IfcReinforcingElement::IfcReinforcingElement(IfcAbstractEntity* e) : IfcBuildingElementComponent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcReinforcingElement::IfcReinforcingElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade) : IfcBuildingElementComponent((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcReinforcingElement::IfcReinforcingElement(IfcAbstractEntity* e) : IfcBuildingElementComponent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcReinforcingElement::IfcReinforcingElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade) : IfcBuildingElementComponent((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcReinforcingMesh -bool IfcReinforcingMesh::hasMeshLength() const { return !entity->getArgument(9)->isNull(); } -double IfcReinforcingMesh::MeshLength() const { return *entity->getArgument(9); } -void IfcReinforcingMesh::setMeshLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcReinforcingMesh::hasMeshWidth() const { return !entity->getArgument(10)->isNull(); } -double IfcReinforcingMesh::MeshWidth() const { return *entity->getArgument(10); } -void IfcReinforcingMesh::setMeshWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -double IfcReinforcingMesh::LongitudinalBarNominalDiameter() const { return *entity->getArgument(11); } -void IfcReinforcingMesh::setLongitudinalBarNominalDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -double IfcReinforcingMesh::TransverseBarNominalDiameter() const { return *entity->getArgument(12); } -void IfcReinforcingMesh::setTransverseBarNominalDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -double IfcReinforcingMesh::LongitudinalBarCrossSectionArea() const { return *entity->getArgument(13); } -void IfcReinforcingMesh::setLongitudinalBarCrossSectionArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -double IfcReinforcingMesh::TransverseBarCrossSectionArea() const { return *entity->getArgument(14); } -void IfcReinforcingMesh::setTransverseBarCrossSectionArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -double IfcReinforcingMesh::LongitudinalBarSpacing() const { return *entity->getArgument(15); } -void IfcReinforcingMesh::setLongitudinalBarSpacing(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v); } -double IfcReinforcingMesh::TransverseBarSpacing() const { return *entity->getArgument(16); } -void IfcReinforcingMesh::setTransverseBarSpacing(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(16,v); } -bool IfcReinforcingMesh::is(Type::Enum v) const { return v == Type::IfcReinforcingMesh || IfcReinforcingElement::is(v); } -Type::Enum IfcReinforcingMesh::type() const { return Type::IfcReinforcingMesh; } +bool IfcReinforcingMesh::hasMeshLength() const { return !data_->getArgument(9)->isNull(); } +double IfcReinforcingMesh::MeshLength() const { return *data_->getArgument(9); } +void IfcReinforcingMesh::setMeshLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcReinforcingMesh::hasMeshWidth() const { return !data_->getArgument(10)->isNull(); } +double IfcReinforcingMesh::MeshWidth() const { return *data_->getArgument(10); } +void IfcReinforcingMesh::setMeshWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +double IfcReinforcingMesh::LongitudinalBarNominalDiameter() const { return *data_->getArgument(11); } +void IfcReinforcingMesh::setLongitudinalBarNominalDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +double IfcReinforcingMesh::TransverseBarNominalDiameter() const { return *data_->getArgument(12); } +void IfcReinforcingMesh::setTransverseBarNominalDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +double IfcReinforcingMesh::LongitudinalBarCrossSectionArea() const { return *data_->getArgument(13); } +void IfcReinforcingMesh::setLongitudinalBarCrossSectionArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +double IfcReinforcingMesh::TransverseBarCrossSectionArea() const { return *data_->getArgument(14); } +void IfcReinforcingMesh::setTransverseBarCrossSectionArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } +double IfcReinforcingMesh::LongitudinalBarSpacing() const { return *data_->getArgument(15); } +void IfcReinforcingMesh::setLongitudinalBarSpacing(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v); } +double IfcReinforcingMesh::TransverseBarSpacing() const { return *data_->getArgument(16); } +void IfcReinforcingMesh::setTransverseBarSpacing(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(16,v); } + + +const IfcParse::entity& IfcReinforcingMesh::declaration() const { return *IfcReinforcingMesh_type; } Type::Enum IfcReinforcingMesh::Class() { return Type::IfcReinforcingMesh; } -IfcReinforcingMesh::IfcReinforcingMesh(IfcAbstractEntity* e) : IfcReinforcingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingMesh)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcReinforcingMesh::IfcReinforcingMesh(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, boost::optional< double > v10_MeshLength, boost::optional< double > v11_MeshWidth, double v12_LongitudinalBarNominalDiameter, double v13_TransverseBarNominalDiameter, double v14_LongitudinalBarCrossSectionArea, double v15_TransverseBarCrossSectionArea, double v16_LongitudinalBarSpacing, double v17_TransverseBarSpacing) : IfcReinforcingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } if (v10_MeshLength) { e->setArgument(9,(*v10_MeshLength)); } else { e->setArgument(9); } if (v11_MeshWidth) { e->setArgument(10,(*v11_MeshWidth)); } else { e->setArgument(10); } e->setArgument(11,(v12_LongitudinalBarNominalDiameter)); e->setArgument(12,(v13_TransverseBarNominalDiameter)); e->setArgument(13,(v14_LongitudinalBarCrossSectionArea)); e->setArgument(14,(v15_TransverseBarCrossSectionArea)); e->setArgument(15,(v16_LongitudinalBarSpacing)); e->setArgument(16,(v17_TransverseBarSpacing)); entity = e; EntityBuffer::Add(this); } +IfcReinforcingMesh::IfcReinforcingMesh(IfcAbstractEntity* e) : IfcReinforcingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingMesh)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcReinforcingMesh::IfcReinforcingMesh(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, boost::optional< double > v10_MeshLength, boost::optional< double > v11_MeshWidth, double v12_LongitudinalBarNominalDiameter, double v13_TransverseBarNominalDiameter, double v14_LongitudinalBarCrossSectionArea, double v15_TransverseBarCrossSectionArea, double v16_LongitudinalBarSpacing, double v17_TransverseBarSpacing) : IfcReinforcingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } if (v10_MeshLength) { e->setArgument(9,(*v10_MeshLength)); } else { e->setArgument(9); } if (v11_MeshWidth) { e->setArgument(10,(*v11_MeshWidth)); } else { e->setArgument(10); } e->setArgument(11,(v12_LongitudinalBarNominalDiameter)); e->setArgument(12,(v13_TransverseBarNominalDiameter)); e->setArgument(13,(v14_LongitudinalBarCrossSectionArea)); e->setArgument(14,(v15_TransverseBarCrossSectionArea)); e->setArgument(15,(v16_LongitudinalBarSpacing)); e->setArgument(16,(v17_TransverseBarSpacing)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAggregates -bool IfcRelAggregates::is(Type::Enum v) const { return v == Type::IfcRelAggregates || IfcRelDecomposes::is(v); } -Type::Enum IfcRelAggregates::type() const { return Type::IfcRelAggregates; } + + +const IfcParse::entity& IfcRelAggregates::declaration() const { return *IfcRelAggregates_type; } Type::Enum IfcRelAggregates::Class() { return Type::IfcRelAggregates; } -IfcRelAggregates::IfcRelAggregates(IfcAbstractEntity* e) : IfcRelDecomposes((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAggregates)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAggregates::IfcRelAggregates(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcObjectDefinition* v5_RelatingObject, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v6_RelatedObjects) : IfcRelDecomposes((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingObject)); e->setArgument(5,(v6_RelatedObjects)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcRelAggregates::IfcRelAggregates(IfcAbstractEntity* e) : IfcRelDecomposes((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAggregates)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAggregates::IfcRelAggregates(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcObjectDefinition* v5_RelatingObject, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v6_RelatedObjects) : IfcRelDecomposes((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingObject)); e->setArgument(5,(v6_RelatedObjects)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssigns -IfcTemplatedEntityList< IfcObjectDefinition >::ptr IfcRelAssigns::RelatedObjects() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcRelAssigns::setRelatedObjects(IfcTemplatedEntityList< IfcObjectDefinition >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -bool IfcRelAssigns::hasRelatedObjectsType() const { return !entity->getArgument(5)->isNull(); } -IfcObjectTypeEnum::IfcObjectTypeEnum IfcRelAssigns::RelatedObjectsType() const { return IfcObjectTypeEnum::FromString(*entity->getArgument(5)); } -void IfcRelAssigns::setRelatedObjectsType(IfcObjectTypeEnum::IfcObjectTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcObjectTypeEnum::ToString(v)); } -bool IfcRelAssigns::is(Type::Enum v) const { return v == Type::IfcRelAssigns || IfcRelationship::is(v); } -Type::Enum IfcRelAssigns::type() const { return Type::IfcRelAssigns; } +IfcTemplatedEntityList< IfcObjectDefinition >::ptr IfcRelAssigns::RelatedObjects() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcRelAssigns::setRelatedObjects(IfcTemplatedEntityList< IfcObjectDefinition >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } +bool IfcRelAssigns::hasRelatedObjectsType() const { return !data_->getArgument(5)->isNull(); } +IfcObjectTypeEnum::IfcObjectTypeEnum IfcRelAssigns::RelatedObjectsType() const { return IfcObjectTypeEnum::FromString(*data_->getArgument(5)); } +void IfcRelAssigns::setRelatedObjectsType(IfcObjectTypeEnum::IfcObjectTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcObjectTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcRelAssigns::declaration() const { return *IfcRelAssigns_type; } Type::Enum IfcRelAssigns::Class() { return Type::IfcRelAssigns; } -IfcRelAssigns::IfcRelAssigns(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssigns)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssigns::IfcRelAssigns(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType) : IfcRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcRelAssigns::IfcRelAssigns(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssigns)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssigns::IfcRelAssigns(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType) : IfcRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssignsTasks -bool IfcRelAssignsTasks::hasTimeForTask() const { return !entity->getArgument(7)->isNull(); } -IfcScheduleTimeControl* IfcRelAssignsTasks::TimeForTask() const { return (IfcScheduleTimeControl*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcRelAssignsTasks::setTimeForTask(IfcScheduleTimeControl* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcRelAssignsTasks::is(Type::Enum v) const { return v == Type::IfcRelAssignsTasks || IfcRelAssignsToControl::is(v); } -Type::Enum IfcRelAssignsTasks::type() const { return Type::IfcRelAssignsTasks; } +bool IfcRelAssignsTasks::hasTimeForTask() const { return !data_->getArgument(7)->isNull(); } +IfcScheduleTimeControl* IfcRelAssignsTasks::TimeForTask() const { return (IfcScheduleTimeControl*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcRelAssignsTasks::setTimeForTask(IfcScheduleTimeControl* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcRelAssignsTasks::declaration() const { return *IfcRelAssignsTasks_type; } Type::Enum IfcRelAssignsTasks::Class() { return Type::IfcRelAssignsTasks; } -IfcRelAssignsTasks::IfcRelAssignsTasks(IfcAbstractEntity* e) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsTasks)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssignsTasks::IfcRelAssignsTasks(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl, IfcScheduleTimeControl* v8_TimeForTask) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingControl)); e->setArgument(7,(v8_TimeForTask)); entity = e; EntityBuffer::Add(this); } +IfcRelAssignsTasks::IfcRelAssignsTasks(IfcAbstractEntity* e) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsTasks)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssignsTasks::IfcRelAssignsTasks(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl, IfcScheduleTimeControl* v8_TimeForTask) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingControl)); e->setArgument(7,(v8_TimeForTask)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssignsToActor -IfcActor* IfcRelAssignsToActor::RelatingActor() const { return (IfcActor*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelAssignsToActor::setRelatingActor(IfcActor* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelAssignsToActor::hasActingRole() const { return !entity->getArgument(7)->isNull(); } -IfcActorRole* IfcRelAssignsToActor::ActingRole() const { return (IfcActorRole*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcRelAssignsToActor::setActingRole(IfcActorRole* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcRelAssignsToActor::is(Type::Enum v) const { return v == Type::IfcRelAssignsToActor || IfcRelAssigns::is(v); } -Type::Enum IfcRelAssignsToActor::type() const { return Type::IfcRelAssignsToActor; } +IfcActor* IfcRelAssignsToActor::RelatingActor() const { return (IfcActor*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelAssignsToActor::setRelatingActor(IfcActor* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcRelAssignsToActor::hasActingRole() const { return !data_->getArgument(7)->isNull(); } +IfcActorRole* IfcRelAssignsToActor::ActingRole() const { return (IfcActorRole*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcRelAssignsToActor::setActingRole(IfcActorRole* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcRelAssignsToActor::declaration() const { return *IfcRelAssignsToActor_type; } Type::Enum IfcRelAssignsToActor::Class() { return Type::IfcRelAssignsToActor; } -IfcRelAssignsToActor::IfcRelAssignsToActor(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToActor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssignsToActor::IfcRelAssignsToActor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcActor* v7_RelatingActor, IfcActorRole* v8_ActingRole) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingActor)); e->setArgument(7,(v8_ActingRole)); entity = e; EntityBuffer::Add(this); } +IfcRelAssignsToActor::IfcRelAssignsToActor(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToActor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssignsToActor::IfcRelAssignsToActor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcActor* v7_RelatingActor, IfcActorRole* v8_ActingRole) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingActor)); e->setArgument(7,(v8_ActingRole)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssignsToControl -IfcControl* IfcRelAssignsToControl::RelatingControl() const { return (IfcControl*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelAssignsToControl::setRelatingControl(IfcControl* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelAssignsToControl::is(Type::Enum v) const { return v == Type::IfcRelAssignsToControl || IfcRelAssigns::is(v); } -Type::Enum IfcRelAssignsToControl::type() const { return Type::IfcRelAssignsToControl; } +IfcControl* IfcRelAssignsToControl::RelatingControl() const { return (IfcControl*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelAssignsToControl::setRelatingControl(IfcControl* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcRelAssignsToControl::declaration() const { return *IfcRelAssignsToControl_type; } Type::Enum IfcRelAssignsToControl::Class() { return Type::IfcRelAssignsToControl; } -IfcRelAssignsToControl::IfcRelAssignsToControl(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToControl)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssignsToControl::IfcRelAssignsToControl(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingControl)); entity = e; EntityBuffer::Add(this); } +IfcRelAssignsToControl::IfcRelAssignsToControl(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToControl)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssignsToControl::IfcRelAssignsToControl(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingControl)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssignsToGroup -IfcGroup* IfcRelAssignsToGroup::RelatingGroup() const { return (IfcGroup*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelAssignsToGroup::setRelatingGroup(IfcGroup* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelAssignsToGroup::is(Type::Enum v) const { return v == Type::IfcRelAssignsToGroup || IfcRelAssigns::is(v); } -Type::Enum IfcRelAssignsToGroup::type() const { return Type::IfcRelAssignsToGroup; } +IfcGroup* IfcRelAssignsToGroup::RelatingGroup() const { return (IfcGroup*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelAssignsToGroup::setRelatingGroup(IfcGroup* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcRelAssignsToGroup::declaration() const { return *IfcRelAssignsToGroup_type; } Type::Enum IfcRelAssignsToGroup::Class() { return Type::IfcRelAssignsToGroup; } -IfcRelAssignsToGroup::IfcRelAssignsToGroup(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToGroup)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssignsToGroup::IfcRelAssignsToGroup(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcGroup* v7_RelatingGroup) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingGroup)); entity = e; EntityBuffer::Add(this); } +IfcRelAssignsToGroup::IfcRelAssignsToGroup(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToGroup)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssignsToGroup::IfcRelAssignsToGroup(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcGroup* v7_RelatingGroup) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingGroup)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssignsToProcess -IfcProcess* IfcRelAssignsToProcess::RelatingProcess() const { return (IfcProcess*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelAssignsToProcess::setRelatingProcess(IfcProcess* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelAssignsToProcess::hasQuantityInProcess() const { return !entity->getArgument(7)->isNull(); } -IfcMeasureWithUnit* IfcRelAssignsToProcess::QuantityInProcess() const { return (IfcMeasureWithUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcRelAssignsToProcess::setQuantityInProcess(IfcMeasureWithUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcRelAssignsToProcess::is(Type::Enum v) const { return v == Type::IfcRelAssignsToProcess || IfcRelAssigns::is(v); } -Type::Enum IfcRelAssignsToProcess::type() const { return Type::IfcRelAssignsToProcess; } +IfcProcess* IfcRelAssignsToProcess::RelatingProcess() const { return (IfcProcess*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelAssignsToProcess::setRelatingProcess(IfcProcess* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcRelAssignsToProcess::hasQuantityInProcess() const { return !data_->getArgument(7)->isNull(); } +IfcMeasureWithUnit* IfcRelAssignsToProcess::QuantityInProcess() const { return (IfcMeasureWithUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcRelAssignsToProcess::setQuantityInProcess(IfcMeasureWithUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcRelAssignsToProcess::declaration() const { return *IfcRelAssignsToProcess_type; } Type::Enum IfcRelAssignsToProcess::Class() { return Type::IfcRelAssignsToProcess; } -IfcRelAssignsToProcess::IfcRelAssignsToProcess(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToProcess)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssignsToProcess::IfcRelAssignsToProcess(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcProcess* v7_RelatingProcess, IfcMeasureWithUnit* v8_QuantityInProcess) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingProcess)); e->setArgument(7,(v8_QuantityInProcess)); entity = e; EntityBuffer::Add(this); } +IfcRelAssignsToProcess::IfcRelAssignsToProcess(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToProcess)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssignsToProcess::IfcRelAssignsToProcess(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcProcess* v7_RelatingProcess, IfcMeasureWithUnit* v8_QuantityInProcess) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingProcess)); e->setArgument(7,(v8_QuantityInProcess)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssignsToProduct -IfcProduct* IfcRelAssignsToProduct::RelatingProduct() const { return (IfcProduct*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelAssignsToProduct::setRelatingProduct(IfcProduct* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelAssignsToProduct::is(Type::Enum v) const { return v == Type::IfcRelAssignsToProduct || IfcRelAssigns::is(v); } -Type::Enum IfcRelAssignsToProduct::type() const { return Type::IfcRelAssignsToProduct; } +IfcProduct* IfcRelAssignsToProduct::RelatingProduct() const { return (IfcProduct*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelAssignsToProduct::setRelatingProduct(IfcProduct* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcRelAssignsToProduct::declaration() const { return *IfcRelAssignsToProduct_type; } Type::Enum IfcRelAssignsToProduct::Class() { return Type::IfcRelAssignsToProduct; } -IfcRelAssignsToProduct::IfcRelAssignsToProduct(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToProduct)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssignsToProduct::IfcRelAssignsToProduct(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcProduct* v7_RelatingProduct) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingProduct)); entity = e; EntityBuffer::Add(this); } +IfcRelAssignsToProduct::IfcRelAssignsToProduct(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToProduct)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssignsToProduct::IfcRelAssignsToProduct(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcProduct* v7_RelatingProduct) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingProduct)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssignsToProjectOrder -bool IfcRelAssignsToProjectOrder::is(Type::Enum v) const { return v == Type::IfcRelAssignsToProjectOrder || IfcRelAssignsToControl::is(v); } -Type::Enum IfcRelAssignsToProjectOrder::type() const { return Type::IfcRelAssignsToProjectOrder; } + + +const IfcParse::entity& IfcRelAssignsToProjectOrder::declaration() const { return *IfcRelAssignsToProjectOrder_type; } Type::Enum IfcRelAssignsToProjectOrder::Class() { return Type::IfcRelAssignsToProjectOrder; } -IfcRelAssignsToProjectOrder::IfcRelAssignsToProjectOrder(IfcAbstractEntity* e) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToProjectOrder)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssignsToProjectOrder::IfcRelAssignsToProjectOrder(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingControl)); entity = e; EntityBuffer::Add(this); } +IfcRelAssignsToProjectOrder::IfcRelAssignsToProjectOrder(IfcAbstractEntity* e) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToProjectOrder)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssignsToProjectOrder::IfcRelAssignsToProjectOrder(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingControl)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssignsToResource -IfcResource* IfcRelAssignsToResource::RelatingResource() const { return (IfcResource*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelAssignsToResource::setRelatingResource(IfcResource* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelAssignsToResource::is(Type::Enum v) const { return v == Type::IfcRelAssignsToResource || IfcRelAssigns::is(v); } -Type::Enum IfcRelAssignsToResource::type() const { return Type::IfcRelAssignsToResource; } +IfcResource* IfcRelAssignsToResource::RelatingResource() const { return (IfcResource*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelAssignsToResource::setRelatingResource(IfcResource* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcRelAssignsToResource::declaration() const { return *IfcRelAssignsToResource_type; } Type::Enum IfcRelAssignsToResource::Class() { return Type::IfcRelAssignsToResource; } -IfcRelAssignsToResource::IfcRelAssignsToResource(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToResource)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssignsToResource::IfcRelAssignsToResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcResource* v7_RelatingResource) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingResource)); entity = e; EntityBuffer::Add(this); } +IfcRelAssignsToResource::IfcRelAssignsToResource(IfcAbstractEntity* e) : IfcRelAssigns((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToResource)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssignsToResource::IfcRelAssignsToResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcResource* v7_RelatingResource) : IfcRelAssigns((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingResource)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssociates -IfcTemplatedEntityList< IfcRoot >::ptr IfcRelAssociates::RelatedObjects() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcRelAssociates::setRelatedObjects(IfcTemplatedEntityList< IfcRoot >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -bool IfcRelAssociates::is(Type::Enum v) const { return v == Type::IfcRelAssociates || IfcRelationship::is(v); } -Type::Enum IfcRelAssociates::type() const { return Type::IfcRelAssociates; } +IfcTemplatedEntityList< IfcRoot >::ptr IfcRelAssociates::RelatedObjects() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcRelAssociates::setRelatedObjects(IfcTemplatedEntityList< IfcRoot >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } + + +const IfcParse::entity& IfcRelAssociates::declaration() const { return *IfcRelAssociates_type; } Type::Enum IfcRelAssociates::Class() { return Type::IfcRelAssociates; } -IfcRelAssociates::IfcRelAssociates(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociates)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssociates::IfcRelAssociates(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects) : IfcRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcRelAssociates::IfcRelAssociates(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociates)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssociates::IfcRelAssociates(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects) : IfcRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssociatesAppliedValue -IfcAppliedValue* IfcRelAssociatesAppliedValue::RelatingAppliedValue() const { return (IfcAppliedValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelAssociatesAppliedValue::setRelatingAppliedValue(IfcAppliedValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelAssociatesAppliedValue::is(Type::Enum v) const { return v == Type::IfcRelAssociatesAppliedValue || IfcRelAssociates::is(v); } -Type::Enum IfcRelAssociatesAppliedValue::type() const { return Type::IfcRelAssociatesAppliedValue; } +IfcAppliedValue* IfcRelAssociatesAppliedValue::RelatingAppliedValue() const { return (IfcAppliedValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelAssociatesAppliedValue::setRelatingAppliedValue(IfcAppliedValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelAssociatesAppliedValue::declaration() const { return *IfcRelAssociatesAppliedValue_type; } Type::Enum IfcRelAssociatesAppliedValue::Class() { return Type::IfcRelAssociatesAppliedValue; } -IfcRelAssociatesAppliedValue::IfcRelAssociatesAppliedValue(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesAppliedValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssociatesAppliedValue::IfcRelAssociatesAppliedValue(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcAppliedValue* v6_RelatingAppliedValue) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingAppliedValue)); entity = e; EntityBuffer::Add(this); } +IfcRelAssociatesAppliedValue::IfcRelAssociatesAppliedValue(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesAppliedValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssociatesAppliedValue::IfcRelAssociatesAppliedValue(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcAppliedValue* v6_RelatingAppliedValue) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingAppliedValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssociatesApproval -IfcApproval* IfcRelAssociatesApproval::RelatingApproval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelAssociatesApproval::setRelatingApproval(IfcApproval* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelAssociatesApproval::is(Type::Enum v) const { return v == Type::IfcRelAssociatesApproval || IfcRelAssociates::is(v); } -Type::Enum IfcRelAssociatesApproval::type() const { return Type::IfcRelAssociatesApproval; } +IfcApproval* IfcRelAssociatesApproval::RelatingApproval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelAssociatesApproval::setRelatingApproval(IfcApproval* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelAssociatesApproval::declaration() const { return *IfcRelAssociatesApproval_type; } Type::Enum IfcRelAssociatesApproval::Class() { return Type::IfcRelAssociatesApproval; } -IfcRelAssociatesApproval::IfcRelAssociatesApproval(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesApproval)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssociatesApproval::IfcRelAssociatesApproval(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcApproval* v6_RelatingApproval) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingApproval)); entity = e; EntityBuffer::Add(this); } +IfcRelAssociatesApproval::IfcRelAssociatesApproval(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesApproval)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssociatesApproval::IfcRelAssociatesApproval(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcApproval* v6_RelatingApproval) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingApproval)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssociatesClassification -IfcClassificationNotationSelect* IfcRelAssociatesClassification::RelatingClassification() const { return (IfcClassificationNotationSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelAssociatesClassification::setRelatingClassification(IfcClassificationNotationSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelAssociatesClassification::is(Type::Enum v) const { return v == Type::IfcRelAssociatesClassification || IfcRelAssociates::is(v); } -Type::Enum IfcRelAssociatesClassification::type() const { return Type::IfcRelAssociatesClassification; } +IfcClassificationNotationSelect* IfcRelAssociatesClassification::RelatingClassification() const { return (IfcClassificationNotationSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelAssociatesClassification::setRelatingClassification(IfcClassificationNotationSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelAssociatesClassification::declaration() const { return *IfcRelAssociatesClassification_type; } Type::Enum IfcRelAssociatesClassification::Class() { return Type::IfcRelAssociatesClassification; } -IfcRelAssociatesClassification::IfcRelAssociatesClassification(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesClassification)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssociatesClassification::IfcRelAssociatesClassification(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcClassificationNotationSelect* v6_RelatingClassification) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingClassification)); entity = e; EntityBuffer::Add(this); } +IfcRelAssociatesClassification::IfcRelAssociatesClassification(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesClassification)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssociatesClassification::IfcRelAssociatesClassification(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcClassificationNotationSelect* v6_RelatingClassification) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingClassification)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssociatesConstraint -std::string IfcRelAssociatesConstraint::Intent() const { return *entity->getArgument(5); } -void IfcRelAssociatesConstraint::setIntent(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcConstraint* IfcRelAssociatesConstraint::RelatingConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelAssociatesConstraint::setRelatingConstraint(IfcConstraint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelAssociatesConstraint::is(Type::Enum v) const { return v == Type::IfcRelAssociatesConstraint || IfcRelAssociates::is(v); } -Type::Enum IfcRelAssociatesConstraint::type() const { return Type::IfcRelAssociatesConstraint; } +std::string IfcRelAssociatesConstraint::Intent() const { return *data_->getArgument(5); } +void IfcRelAssociatesConstraint::setIntent(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +IfcConstraint* IfcRelAssociatesConstraint::RelatingConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelAssociatesConstraint::setRelatingConstraint(IfcConstraint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcRelAssociatesConstraint::declaration() const { return *IfcRelAssociatesConstraint_type; } Type::Enum IfcRelAssociatesConstraint::Class() { return Type::IfcRelAssociatesConstraint; } -IfcRelAssociatesConstraint::IfcRelAssociatesConstraint(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesConstraint)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssociatesConstraint::IfcRelAssociatesConstraint(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, std::string v6_Intent, IfcConstraint* v7_RelatingConstraint) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_Intent)); e->setArgument(6,(v7_RelatingConstraint)); entity = e; EntityBuffer::Add(this); } +IfcRelAssociatesConstraint::IfcRelAssociatesConstraint(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesConstraint)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssociatesConstraint::IfcRelAssociatesConstraint(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, std::string v6_Intent, IfcConstraint* v7_RelatingConstraint) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_Intent)); e->setArgument(6,(v7_RelatingConstraint)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssociatesDocument -IfcDocumentSelect* IfcRelAssociatesDocument::RelatingDocument() const { return (IfcDocumentSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelAssociatesDocument::setRelatingDocument(IfcDocumentSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelAssociatesDocument::is(Type::Enum v) const { return v == Type::IfcRelAssociatesDocument || IfcRelAssociates::is(v); } -Type::Enum IfcRelAssociatesDocument::type() const { return Type::IfcRelAssociatesDocument; } +IfcDocumentSelect* IfcRelAssociatesDocument::RelatingDocument() const { return (IfcDocumentSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelAssociatesDocument::setRelatingDocument(IfcDocumentSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelAssociatesDocument::declaration() const { return *IfcRelAssociatesDocument_type; } Type::Enum IfcRelAssociatesDocument::Class() { return Type::IfcRelAssociatesDocument; } -IfcRelAssociatesDocument::IfcRelAssociatesDocument(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesDocument)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssociatesDocument::IfcRelAssociatesDocument(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcDocumentSelect* v6_RelatingDocument) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingDocument)); entity = e; EntityBuffer::Add(this); } +IfcRelAssociatesDocument::IfcRelAssociatesDocument(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesDocument)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssociatesDocument::IfcRelAssociatesDocument(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcDocumentSelect* v6_RelatingDocument) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingDocument)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssociatesLibrary -IfcLibrarySelect* IfcRelAssociatesLibrary::RelatingLibrary() const { return (IfcLibrarySelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelAssociatesLibrary::setRelatingLibrary(IfcLibrarySelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelAssociatesLibrary::is(Type::Enum v) const { return v == Type::IfcRelAssociatesLibrary || IfcRelAssociates::is(v); } -Type::Enum IfcRelAssociatesLibrary::type() const { return Type::IfcRelAssociatesLibrary; } +IfcLibrarySelect* IfcRelAssociatesLibrary::RelatingLibrary() const { return (IfcLibrarySelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelAssociatesLibrary::setRelatingLibrary(IfcLibrarySelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelAssociatesLibrary::declaration() const { return *IfcRelAssociatesLibrary_type; } Type::Enum IfcRelAssociatesLibrary::Class() { return Type::IfcRelAssociatesLibrary; } -IfcRelAssociatesLibrary::IfcRelAssociatesLibrary(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesLibrary)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssociatesLibrary::IfcRelAssociatesLibrary(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcLibrarySelect* v6_RelatingLibrary) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingLibrary)); entity = e; EntityBuffer::Add(this); } +IfcRelAssociatesLibrary::IfcRelAssociatesLibrary(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesLibrary)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssociatesLibrary::IfcRelAssociatesLibrary(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcLibrarySelect* v6_RelatingLibrary) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingLibrary)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssociatesMaterial -IfcMaterialSelect* IfcRelAssociatesMaterial::RelatingMaterial() const { return (IfcMaterialSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelAssociatesMaterial::setRelatingMaterial(IfcMaterialSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelAssociatesMaterial::is(Type::Enum v) const { return v == Type::IfcRelAssociatesMaterial || IfcRelAssociates::is(v); } -Type::Enum IfcRelAssociatesMaterial::type() const { return Type::IfcRelAssociatesMaterial; } +IfcMaterialSelect* IfcRelAssociatesMaterial::RelatingMaterial() const { return (IfcMaterialSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelAssociatesMaterial::setRelatingMaterial(IfcMaterialSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelAssociatesMaterial::declaration() const { return *IfcRelAssociatesMaterial_type; } Type::Enum IfcRelAssociatesMaterial::Class() { return Type::IfcRelAssociatesMaterial; } -IfcRelAssociatesMaterial::IfcRelAssociatesMaterial(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesMaterial)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssociatesMaterial::IfcRelAssociatesMaterial(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcMaterialSelect* v6_RelatingMaterial) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingMaterial)); entity = e; EntityBuffer::Add(this); } +IfcRelAssociatesMaterial::IfcRelAssociatesMaterial(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesMaterial)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssociatesMaterial::IfcRelAssociatesMaterial(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcMaterialSelect* v6_RelatingMaterial) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingMaterial)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssociatesProfileProperties -IfcProfileProperties* IfcRelAssociatesProfileProperties::RelatingProfileProperties() const { return (IfcProfileProperties*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelAssociatesProfileProperties::setRelatingProfileProperties(IfcProfileProperties* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelAssociatesProfileProperties::hasProfileSectionLocation() const { return !entity->getArgument(6)->isNull(); } -IfcShapeAspect* IfcRelAssociatesProfileProperties::ProfileSectionLocation() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelAssociatesProfileProperties::setProfileSectionLocation(IfcShapeAspect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelAssociatesProfileProperties::hasProfileOrientation() const { return !entity->getArgument(7)->isNull(); } -IfcOrientationSelect* IfcRelAssociatesProfileProperties::ProfileOrientation() const { return (IfcOrientationSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcRelAssociatesProfileProperties::setProfileOrientation(IfcOrientationSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcRelAssociatesProfileProperties::is(Type::Enum v) const { return v == Type::IfcRelAssociatesProfileProperties || IfcRelAssociates::is(v); } -Type::Enum IfcRelAssociatesProfileProperties::type() const { return Type::IfcRelAssociatesProfileProperties; } +IfcProfileProperties* IfcRelAssociatesProfileProperties::RelatingProfileProperties() const { return (IfcProfileProperties*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelAssociatesProfileProperties::setRelatingProfileProperties(IfcProfileProperties* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcRelAssociatesProfileProperties::hasProfileSectionLocation() const { return !data_->getArgument(6)->isNull(); } +IfcShapeAspect* IfcRelAssociatesProfileProperties::ProfileSectionLocation() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelAssociatesProfileProperties::setProfileSectionLocation(IfcShapeAspect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcRelAssociatesProfileProperties::hasProfileOrientation() const { return !data_->getArgument(7)->isNull(); } +IfcOrientationSelect* IfcRelAssociatesProfileProperties::ProfileOrientation() const { return (IfcOrientationSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcRelAssociatesProfileProperties::setProfileOrientation(IfcOrientationSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcRelAssociatesProfileProperties::declaration() const { return *IfcRelAssociatesProfileProperties_type; } Type::Enum IfcRelAssociatesProfileProperties::Class() { return Type::IfcRelAssociatesProfileProperties; } -IfcRelAssociatesProfileProperties::IfcRelAssociatesProfileProperties(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesProfileProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssociatesProfileProperties::IfcRelAssociatesProfileProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcProfileProperties* v6_RelatingProfileProperties, IfcShapeAspect* v7_ProfileSectionLocation, IfcOrientationSelect* v8_ProfileOrientation) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingProfileProperties)); e->setArgument(6,(v7_ProfileSectionLocation)); e->setArgument(7,(v8_ProfileOrientation)); entity = e; EntityBuffer::Add(this); } +IfcRelAssociatesProfileProperties::IfcRelAssociatesProfileProperties(IfcAbstractEntity* e) : IfcRelAssociates((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssociatesProfileProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssociatesProfileProperties::IfcRelAssociatesProfileProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcProfileProperties* v6_RelatingProfileProperties, IfcShapeAspect* v7_ProfileSectionLocation, IfcOrientationSelect* v8_ProfileOrientation) : IfcRelAssociates((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingProfileProperties)); e->setArgument(6,(v7_ProfileSectionLocation)); e->setArgument(7,(v8_ProfileOrientation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelConnects -bool IfcRelConnects::is(Type::Enum v) const { return v == Type::IfcRelConnects || IfcRelationship::is(v); } -Type::Enum IfcRelConnects::type() const { return Type::IfcRelConnects; } + + +const IfcParse::entity& IfcRelConnects::declaration() const { return *IfcRelConnects_type; } Type::Enum IfcRelConnects::Class() { return Type::IfcRelConnects; } -IfcRelConnects::IfcRelConnects(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnects)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelConnects::IfcRelConnects(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcRelConnects::IfcRelConnects(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnects)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelConnects::IfcRelConnects(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelConnectsElements -bool IfcRelConnectsElements::hasConnectionGeometry() const { return !entity->getArgument(4)->isNull(); } -IfcConnectionGeometry* IfcRelConnectsElements::ConnectionGeometry() const { return (IfcConnectionGeometry*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelConnectsElements::setConnectionGeometry(IfcConnectionGeometry* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcElement* IfcRelConnectsElements::RelatingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelConnectsElements::setRelatingElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcElement* IfcRelConnectsElements::RelatedElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelConnectsElements::setRelatedElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelConnectsElements::is(Type::Enum v) const { return v == Type::IfcRelConnectsElements || IfcRelConnects::is(v); } -Type::Enum IfcRelConnectsElements::type() const { return Type::IfcRelConnectsElements; } +bool IfcRelConnectsElements::hasConnectionGeometry() const { return !data_->getArgument(4)->isNull(); } +IfcConnectionGeometry* IfcRelConnectsElements::ConnectionGeometry() const { return (IfcConnectionGeometry*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelConnectsElements::setConnectionGeometry(IfcConnectionGeometry* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcElement* IfcRelConnectsElements::RelatingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelConnectsElements::setRelatingElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +IfcElement* IfcRelConnectsElements::RelatedElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelConnectsElements::setRelatedElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcRelConnectsElements::declaration() const { return *IfcRelConnectsElements_type; } Type::Enum IfcRelConnectsElements::Class() { return Type::IfcRelConnectsElements; } -IfcRelConnectsElements::IfcRelConnectsElements(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsElements)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelConnectsElements::IfcRelConnectsElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcConnectionGeometry* v5_ConnectionGeometry, IfcElement* v6_RelatingElement, IfcElement* v7_RelatedElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_ConnectionGeometry)); e->setArgument(5,(v6_RelatingElement)); e->setArgument(6,(v7_RelatedElement)); entity = e; EntityBuffer::Add(this); } +IfcRelConnectsElements::IfcRelConnectsElements(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsElements)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelConnectsElements::IfcRelConnectsElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcConnectionGeometry* v5_ConnectionGeometry, IfcElement* v6_RelatingElement, IfcElement* v7_RelatedElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_ConnectionGeometry)); e->setArgument(5,(v6_RelatingElement)); e->setArgument(6,(v7_RelatedElement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelConnectsPathElements -std::vector< int > /*[0:?]*/ IfcRelConnectsPathElements::RelatingPriorities() const { return *entity->getArgument(7); } -void IfcRelConnectsPathElements::setRelatingPriorities(std::vector< int > /*[0:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -std::vector< int > /*[0:?]*/ IfcRelConnectsPathElements::RelatedPriorities() const { return *entity->getArgument(8); } -void IfcRelConnectsPathElements::setRelatedPriorities(std::vector< int > /*[0:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -IfcConnectionTypeEnum::IfcConnectionTypeEnum IfcRelConnectsPathElements::RelatedConnectionType() const { return IfcConnectionTypeEnum::FromString(*entity->getArgument(9)); } -void IfcRelConnectsPathElements::setRelatedConnectionType(IfcConnectionTypeEnum::IfcConnectionTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcConnectionTypeEnum::ToString(v)); } -IfcConnectionTypeEnum::IfcConnectionTypeEnum IfcRelConnectsPathElements::RelatingConnectionType() const { return IfcConnectionTypeEnum::FromString(*entity->getArgument(10)); } -void IfcRelConnectsPathElements::setRelatingConnectionType(IfcConnectionTypeEnum::IfcConnectionTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcConnectionTypeEnum::ToString(v)); } -bool IfcRelConnectsPathElements::is(Type::Enum v) const { return v == Type::IfcRelConnectsPathElements || IfcRelConnectsElements::is(v); } -Type::Enum IfcRelConnectsPathElements::type() const { return Type::IfcRelConnectsPathElements; } +std::vector< int > /*[0:?]*/ IfcRelConnectsPathElements::RelatingPriorities() const { return *data_->getArgument(7); } +void IfcRelConnectsPathElements::setRelatingPriorities(std::vector< int > /*[0:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +std::vector< int > /*[0:?]*/ IfcRelConnectsPathElements::RelatedPriorities() const { return *data_->getArgument(8); } +void IfcRelConnectsPathElements::setRelatedPriorities(std::vector< int > /*[0:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +IfcConnectionTypeEnum::IfcConnectionTypeEnum IfcRelConnectsPathElements::RelatedConnectionType() const { return IfcConnectionTypeEnum::FromString(*data_->getArgument(9)); } +void IfcRelConnectsPathElements::setRelatedConnectionType(IfcConnectionTypeEnum::IfcConnectionTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcConnectionTypeEnum::ToString(v)); } +IfcConnectionTypeEnum::IfcConnectionTypeEnum IfcRelConnectsPathElements::RelatingConnectionType() const { return IfcConnectionTypeEnum::FromString(*data_->getArgument(10)); } +void IfcRelConnectsPathElements::setRelatingConnectionType(IfcConnectionTypeEnum::IfcConnectionTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcConnectionTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcRelConnectsPathElements::declaration() const { return *IfcRelConnectsPathElements_type; } Type::Enum IfcRelConnectsPathElements::Class() { return Type::IfcRelConnectsPathElements; } -IfcRelConnectsPathElements::IfcRelConnectsPathElements(IfcAbstractEntity* e) : IfcRelConnectsElements((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsPathElements)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelConnectsPathElements::IfcRelConnectsPathElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcConnectionGeometry* v5_ConnectionGeometry, IfcElement* v6_RelatingElement, IfcElement* v7_RelatedElement, std::vector< int > /*[0:?]*/ v8_RelatingPriorities, std::vector< int > /*[0:?]*/ v9_RelatedPriorities, IfcConnectionTypeEnum::IfcConnectionTypeEnum v10_RelatedConnectionType, IfcConnectionTypeEnum::IfcConnectionTypeEnum v11_RelatingConnectionType) : IfcRelConnectsElements((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_ConnectionGeometry)); e->setArgument(5,(v6_RelatingElement)); e->setArgument(6,(v7_RelatedElement)); e->setArgument(7,(v8_RelatingPriorities)); e->setArgument(8,(v9_RelatedPriorities)); e->setArgument(9,v10_RelatedConnectionType,IfcConnectionTypeEnum::ToString(v10_RelatedConnectionType)); e->setArgument(10,v11_RelatingConnectionType,IfcConnectionTypeEnum::ToString(v11_RelatingConnectionType)); entity = e; EntityBuffer::Add(this); } +IfcRelConnectsPathElements::IfcRelConnectsPathElements(IfcAbstractEntity* e) : IfcRelConnectsElements((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsPathElements)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelConnectsPathElements::IfcRelConnectsPathElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcConnectionGeometry* v5_ConnectionGeometry, IfcElement* v6_RelatingElement, IfcElement* v7_RelatedElement, std::vector< int > /*[0:?]*/ v8_RelatingPriorities, std::vector< int > /*[0:?]*/ v9_RelatedPriorities, IfcConnectionTypeEnum::IfcConnectionTypeEnum v10_RelatedConnectionType, IfcConnectionTypeEnum::IfcConnectionTypeEnum v11_RelatingConnectionType) : IfcRelConnectsElements((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_ConnectionGeometry)); e->setArgument(5,(v6_RelatingElement)); e->setArgument(6,(v7_RelatedElement)); e->setArgument(7,(v8_RelatingPriorities)); e->setArgument(8,(v9_RelatedPriorities)); e->setArgument(9,v10_RelatedConnectionType,IfcConnectionTypeEnum::ToString(v10_RelatedConnectionType)); e->setArgument(10,v11_RelatingConnectionType,IfcConnectionTypeEnum::ToString(v11_RelatingConnectionType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelConnectsPortToElement -IfcPort* IfcRelConnectsPortToElement::RelatingPort() const { return (IfcPort*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelConnectsPortToElement::setRelatingPort(IfcPort* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcElement* IfcRelConnectsPortToElement::RelatedElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelConnectsPortToElement::setRelatedElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelConnectsPortToElement::is(Type::Enum v) const { return v == Type::IfcRelConnectsPortToElement || IfcRelConnects::is(v); } -Type::Enum IfcRelConnectsPortToElement::type() const { return Type::IfcRelConnectsPortToElement; } +IfcPort* IfcRelConnectsPortToElement::RelatingPort() const { return (IfcPort*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelConnectsPortToElement::setRelatingPort(IfcPort* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcElement* IfcRelConnectsPortToElement::RelatedElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelConnectsPortToElement::setRelatedElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelConnectsPortToElement::declaration() const { return *IfcRelConnectsPortToElement_type; } Type::Enum IfcRelConnectsPortToElement::Class() { return Type::IfcRelConnectsPortToElement; } -IfcRelConnectsPortToElement::IfcRelConnectsPortToElement(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsPortToElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelConnectsPortToElement::IfcRelConnectsPortToElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPort* v5_RelatingPort, IfcElement* v6_RelatedElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingPort)); e->setArgument(5,(v6_RelatedElement)); entity = e; EntityBuffer::Add(this); } +IfcRelConnectsPortToElement::IfcRelConnectsPortToElement(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsPortToElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelConnectsPortToElement::IfcRelConnectsPortToElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPort* v5_RelatingPort, IfcElement* v6_RelatedElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingPort)); e->setArgument(5,(v6_RelatedElement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelConnectsPorts -IfcPort* IfcRelConnectsPorts::RelatingPort() const { return (IfcPort*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelConnectsPorts::setRelatingPort(IfcPort* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcPort* IfcRelConnectsPorts::RelatedPort() const { return (IfcPort*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelConnectsPorts::setRelatedPort(IfcPort* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelConnectsPorts::hasRealizingElement() const { return !entity->getArgument(6)->isNull(); } -IfcElement* IfcRelConnectsPorts::RealizingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelConnectsPorts::setRealizingElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelConnectsPorts::is(Type::Enum v) const { return v == Type::IfcRelConnectsPorts || IfcRelConnects::is(v); } -Type::Enum IfcRelConnectsPorts::type() const { return Type::IfcRelConnectsPorts; } +IfcPort* IfcRelConnectsPorts::RelatingPort() const { return (IfcPort*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelConnectsPorts::setRelatingPort(IfcPort* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcPort* IfcRelConnectsPorts::RelatedPort() const { return (IfcPort*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelConnectsPorts::setRelatedPort(IfcPort* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcRelConnectsPorts::hasRealizingElement() const { return !data_->getArgument(6)->isNull(); } +IfcElement* IfcRelConnectsPorts::RealizingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelConnectsPorts::setRealizingElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcRelConnectsPorts::declaration() const { return *IfcRelConnectsPorts_type; } Type::Enum IfcRelConnectsPorts::Class() { return Type::IfcRelConnectsPorts; } -IfcRelConnectsPorts::IfcRelConnectsPorts(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsPorts)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelConnectsPorts::IfcRelConnectsPorts(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPort* v5_RelatingPort, IfcPort* v6_RelatedPort, IfcElement* v7_RealizingElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingPort)); e->setArgument(5,(v6_RelatedPort)); e->setArgument(6,(v7_RealizingElement)); entity = e; EntityBuffer::Add(this); } +IfcRelConnectsPorts::IfcRelConnectsPorts(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsPorts)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelConnectsPorts::IfcRelConnectsPorts(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPort* v5_RelatingPort, IfcPort* v6_RelatedPort, IfcElement* v7_RealizingElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingPort)); e->setArgument(5,(v6_RelatedPort)); e->setArgument(6,(v7_RealizingElement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelConnectsStructuralActivity -IfcStructuralActivityAssignmentSelect* IfcRelConnectsStructuralActivity::RelatingElement() const { return (IfcStructuralActivityAssignmentSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelConnectsStructuralActivity::setRelatingElement(IfcStructuralActivityAssignmentSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcStructuralActivity* IfcRelConnectsStructuralActivity::RelatedStructuralActivity() const { return (IfcStructuralActivity*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelConnectsStructuralActivity::setRelatedStructuralActivity(IfcStructuralActivity* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelConnectsStructuralActivity::is(Type::Enum v) const { return v == Type::IfcRelConnectsStructuralActivity || IfcRelConnects::is(v); } -Type::Enum IfcRelConnectsStructuralActivity::type() const { return Type::IfcRelConnectsStructuralActivity; } +IfcStructuralActivityAssignmentSelect* IfcRelConnectsStructuralActivity::RelatingElement() const { return (IfcStructuralActivityAssignmentSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelConnectsStructuralActivity::setRelatingElement(IfcStructuralActivityAssignmentSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcStructuralActivity* IfcRelConnectsStructuralActivity::RelatedStructuralActivity() const { return (IfcStructuralActivity*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelConnectsStructuralActivity::setRelatedStructuralActivity(IfcStructuralActivity* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelConnectsStructuralActivity::declaration() const { return *IfcRelConnectsStructuralActivity_type; } Type::Enum IfcRelConnectsStructuralActivity::Class() { return Type::IfcRelConnectsStructuralActivity; } -IfcRelConnectsStructuralActivity::IfcRelConnectsStructuralActivity(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsStructuralActivity)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelConnectsStructuralActivity::IfcRelConnectsStructuralActivity(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcStructuralActivityAssignmentSelect* v5_RelatingElement, IfcStructuralActivity* v6_RelatedStructuralActivity) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingElement)); e->setArgument(5,(v6_RelatedStructuralActivity)); entity = e; EntityBuffer::Add(this); } +IfcRelConnectsStructuralActivity::IfcRelConnectsStructuralActivity(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsStructuralActivity)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelConnectsStructuralActivity::IfcRelConnectsStructuralActivity(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcStructuralActivityAssignmentSelect* v5_RelatingElement, IfcStructuralActivity* v6_RelatedStructuralActivity) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingElement)); e->setArgument(5,(v6_RelatedStructuralActivity)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelConnectsStructuralElement -IfcElement* IfcRelConnectsStructuralElement::RelatingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelConnectsStructuralElement::setRelatingElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcStructuralMember* IfcRelConnectsStructuralElement::RelatedStructuralMember() const { return (IfcStructuralMember*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelConnectsStructuralElement::setRelatedStructuralMember(IfcStructuralMember* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelConnectsStructuralElement::is(Type::Enum v) const { return v == Type::IfcRelConnectsStructuralElement || IfcRelConnects::is(v); } -Type::Enum IfcRelConnectsStructuralElement::type() const { return Type::IfcRelConnectsStructuralElement; } +IfcElement* IfcRelConnectsStructuralElement::RelatingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelConnectsStructuralElement::setRelatingElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcStructuralMember* IfcRelConnectsStructuralElement::RelatedStructuralMember() const { return (IfcStructuralMember*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelConnectsStructuralElement::setRelatedStructuralMember(IfcStructuralMember* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelConnectsStructuralElement::declaration() const { return *IfcRelConnectsStructuralElement_type; } Type::Enum IfcRelConnectsStructuralElement::Class() { return Type::IfcRelConnectsStructuralElement; } -IfcRelConnectsStructuralElement::IfcRelConnectsStructuralElement(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsStructuralElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelConnectsStructuralElement::IfcRelConnectsStructuralElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingElement, IfcStructuralMember* v6_RelatedStructuralMember) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingElement)); e->setArgument(5,(v6_RelatedStructuralMember)); entity = e; EntityBuffer::Add(this); } +IfcRelConnectsStructuralElement::IfcRelConnectsStructuralElement(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsStructuralElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelConnectsStructuralElement::IfcRelConnectsStructuralElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingElement, IfcStructuralMember* v6_RelatedStructuralMember) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingElement)); e->setArgument(5,(v6_RelatedStructuralMember)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelConnectsStructuralMember -IfcStructuralMember* IfcRelConnectsStructuralMember::RelatingStructuralMember() const { return (IfcStructuralMember*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelConnectsStructuralMember::setRelatingStructuralMember(IfcStructuralMember* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcStructuralConnection* IfcRelConnectsStructuralMember::RelatedStructuralConnection() const { return (IfcStructuralConnection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelConnectsStructuralMember::setRelatedStructuralConnection(IfcStructuralConnection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelConnectsStructuralMember::hasAppliedCondition() const { return !entity->getArgument(6)->isNull(); } -IfcBoundaryCondition* IfcRelConnectsStructuralMember::AppliedCondition() const { return (IfcBoundaryCondition*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelConnectsStructuralMember::setAppliedCondition(IfcBoundaryCondition* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelConnectsStructuralMember::hasAdditionalConditions() const { return !entity->getArgument(7)->isNull(); } -IfcStructuralConnectionCondition* IfcRelConnectsStructuralMember::AdditionalConditions() const { return (IfcStructuralConnectionCondition*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcRelConnectsStructuralMember::setAdditionalConditions(IfcStructuralConnectionCondition* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcRelConnectsStructuralMember::hasSupportedLength() const { return !entity->getArgument(8)->isNull(); } -double IfcRelConnectsStructuralMember::SupportedLength() const { return *entity->getArgument(8); } -void IfcRelConnectsStructuralMember::setSupportedLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcRelConnectsStructuralMember::hasConditionCoordinateSystem() const { return !entity->getArgument(9)->isNull(); } -IfcAxis2Placement3D* IfcRelConnectsStructuralMember::ConditionCoordinateSystem() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcRelConnectsStructuralMember::setConditionCoordinateSystem(IfcAxis2Placement3D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcRelConnectsStructuralMember::is(Type::Enum v) const { return v == Type::IfcRelConnectsStructuralMember || IfcRelConnects::is(v); } -Type::Enum IfcRelConnectsStructuralMember::type() const { return Type::IfcRelConnectsStructuralMember; } +IfcStructuralMember* IfcRelConnectsStructuralMember::RelatingStructuralMember() const { return (IfcStructuralMember*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelConnectsStructuralMember::setRelatingStructuralMember(IfcStructuralMember* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcStructuralConnection* IfcRelConnectsStructuralMember::RelatedStructuralConnection() const { return (IfcStructuralConnection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelConnectsStructuralMember::setRelatedStructuralConnection(IfcStructuralConnection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcRelConnectsStructuralMember::hasAppliedCondition() const { return !data_->getArgument(6)->isNull(); } +IfcBoundaryCondition* IfcRelConnectsStructuralMember::AppliedCondition() const { return (IfcBoundaryCondition*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelConnectsStructuralMember::setAppliedCondition(IfcBoundaryCondition* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcRelConnectsStructuralMember::hasAdditionalConditions() const { return !data_->getArgument(7)->isNull(); } +IfcStructuralConnectionCondition* IfcRelConnectsStructuralMember::AdditionalConditions() const { return (IfcStructuralConnectionCondition*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcRelConnectsStructuralMember::setAdditionalConditions(IfcStructuralConnectionCondition* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcRelConnectsStructuralMember::hasSupportedLength() const { return !data_->getArgument(8)->isNull(); } +double IfcRelConnectsStructuralMember::SupportedLength() const { return *data_->getArgument(8); } +void IfcRelConnectsStructuralMember::setSupportedLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcRelConnectsStructuralMember::hasConditionCoordinateSystem() const { return !data_->getArgument(9)->isNull(); } +IfcAxis2Placement3D* IfcRelConnectsStructuralMember::ConditionCoordinateSystem() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcRelConnectsStructuralMember::setConditionCoordinateSystem(IfcAxis2Placement3D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcRelConnectsStructuralMember::declaration() const { return *IfcRelConnectsStructuralMember_type; } Type::Enum IfcRelConnectsStructuralMember::Class() { return Type::IfcRelConnectsStructuralMember; } -IfcRelConnectsStructuralMember::IfcRelConnectsStructuralMember(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsStructuralMember)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelConnectsStructuralMember::IfcRelConnectsStructuralMember(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcStructuralMember* v5_RelatingStructuralMember, IfcStructuralConnection* v6_RelatedStructuralConnection, IfcBoundaryCondition* v7_AppliedCondition, IfcStructuralConnectionCondition* v8_AdditionalConditions, boost::optional< double > v9_SupportedLength, IfcAxis2Placement3D* v10_ConditionCoordinateSystem) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingStructuralMember)); e->setArgument(5,(v6_RelatedStructuralConnection)); e->setArgument(6,(v7_AppliedCondition)); e->setArgument(7,(v8_AdditionalConditions)); if (v9_SupportedLength) { e->setArgument(8,(*v9_SupportedLength)); } else { e->setArgument(8); } e->setArgument(9,(v10_ConditionCoordinateSystem)); entity = e; EntityBuffer::Add(this); } +IfcRelConnectsStructuralMember::IfcRelConnectsStructuralMember(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsStructuralMember)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelConnectsStructuralMember::IfcRelConnectsStructuralMember(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcStructuralMember* v5_RelatingStructuralMember, IfcStructuralConnection* v6_RelatedStructuralConnection, IfcBoundaryCondition* v7_AppliedCondition, IfcStructuralConnectionCondition* v8_AdditionalConditions, boost::optional< double > v9_SupportedLength, IfcAxis2Placement3D* v10_ConditionCoordinateSystem) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingStructuralMember)); e->setArgument(5,(v6_RelatedStructuralConnection)); e->setArgument(6,(v7_AppliedCondition)); e->setArgument(7,(v8_AdditionalConditions)); if (v9_SupportedLength) { e->setArgument(8,(*v9_SupportedLength)); } else { e->setArgument(8); } e->setArgument(9,(v10_ConditionCoordinateSystem)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelConnectsWithEccentricity -IfcConnectionGeometry* IfcRelConnectsWithEccentricity::ConnectionConstraint() const { return (IfcConnectionGeometry*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcRelConnectsWithEccentricity::setConnectionConstraint(IfcConnectionGeometry* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcRelConnectsWithEccentricity::is(Type::Enum v) const { return v == Type::IfcRelConnectsWithEccentricity || IfcRelConnectsStructuralMember::is(v); } -Type::Enum IfcRelConnectsWithEccentricity::type() const { return Type::IfcRelConnectsWithEccentricity; } +IfcConnectionGeometry* IfcRelConnectsWithEccentricity::ConnectionConstraint() const { return (IfcConnectionGeometry*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcRelConnectsWithEccentricity::setConnectionConstraint(IfcConnectionGeometry* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcRelConnectsWithEccentricity::declaration() const { return *IfcRelConnectsWithEccentricity_type; } Type::Enum IfcRelConnectsWithEccentricity::Class() { return Type::IfcRelConnectsWithEccentricity; } -IfcRelConnectsWithEccentricity::IfcRelConnectsWithEccentricity(IfcAbstractEntity* e) : IfcRelConnectsStructuralMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsWithEccentricity)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelConnectsWithEccentricity::IfcRelConnectsWithEccentricity(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcStructuralMember* v5_RelatingStructuralMember, IfcStructuralConnection* v6_RelatedStructuralConnection, IfcBoundaryCondition* v7_AppliedCondition, IfcStructuralConnectionCondition* v8_AdditionalConditions, boost::optional< double > v9_SupportedLength, IfcAxis2Placement3D* v10_ConditionCoordinateSystem, IfcConnectionGeometry* v11_ConnectionConstraint) : IfcRelConnectsStructuralMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingStructuralMember)); e->setArgument(5,(v6_RelatedStructuralConnection)); e->setArgument(6,(v7_AppliedCondition)); e->setArgument(7,(v8_AdditionalConditions)); if (v9_SupportedLength) { e->setArgument(8,(*v9_SupportedLength)); } else { e->setArgument(8); } e->setArgument(9,(v10_ConditionCoordinateSystem)); e->setArgument(10,(v11_ConnectionConstraint)); entity = e; EntityBuffer::Add(this); } +IfcRelConnectsWithEccentricity::IfcRelConnectsWithEccentricity(IfcAbstractEntity* e) : IfcRelConnectsStructuralMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsWithEccentricity)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelConnectsWithEccentricity::IfcRelConnectsWithEccentricity(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcStructuralMember* v5_RelatingStructuralMember, IfcStructuralConnection* v6_RelatedStructuralConnection, IfcBoundaryCondition* v7_AppliedCondition, IfcStructuralConnectionCondition* v8_AdditionalConditions, boost::optional< double > v9_SupportedLength, IfcAxis2Placement3D* v10_ConditionCoordinateSystem, IfcConnectionGeometry* v11_ConnectionConstraint) : IfcRelConnectsStructuralMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingStructuralMember)); e->setArgument(5,(v6_RelatedStructuralConnection)); e->setArgument(6,(v7_AppliedCondition)); e->setArgument(7,(v8_AdditionalConditions)); if (v9_SupportedLength) { e->setArgument(8,(*v9_SupportedLength)); } else { e->setArgument(8); } e->setArgument(9,(v10_ConditionCoordinateSystem)); e->setArgument(10,(v11_ConnectionConstraint)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelConnectsWithRealizingElements -IfcTemplatedEntityList< IfcElement >::ptr IfcRelConnectsWithRealizingElements::RealizingElements() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcRelConnectsWithRealizingElements::setRealizingElements(IfcTemplatedEntityList< IfcElement >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -bool IfcRelConnectsWithRealizingElements::hasConnectionType() const { return !entity->getArgument(8)->isNull(); } -std::string IfcRelConnectsWithRealizingElements::ConnectionType() const { return *entity->getArgument(8); } -void IfcRelConnectsWithRealizingElements::setConnectionType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcRelConnectsWithRealizingElements::is(Type::Enum v) const { return v == Type::IfcRelConnectsWithRealizingElements || IfcRelConnectsElements::is(v); } -Type::Enum IfcRelConnectsWithRealizingElements::type() const { return Type::IfcRelConnectsWithRealizingElements; } +IfcTemplatedEntityList< IfcElement >::ptr IfcRelConnectsWithRealizingElements::RealizingElements() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcRelConnectsWithRealizingElements::setRealizingElements(IfcTemplatedEntityList< IfcElement >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } +bool IfcRelConnectsWithRealizingElements::hasConnectionType() const { return !data_->getArgument(8)->isNull(); } +std::string IfcRelConnectsWithRealizingElements::ConnectionType() const { return *data_->getArgument(8); } +void IfcRelConnectsWithRealizingElements::setConnectionType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcRelConnectsWithRealizingElements::declaration() const { return *IfcRelConnectsWithRealizingElements_type; } Type::Enum IfcRelConnectsWithRealizingElements::Class() { return Type::IfcRelConnectsWithRealizingElements; } -IfcRelConnectsWithRealizingElements::IfcRelConnectsWithRealizingElements(IfcAbstractEntity* e) : IfcRelConnectsElements((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsWithRealizingElements)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelConnectsWithRealizingElements::IfcRelConnectsWithRealizingElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcConnectionGeometry* v5_ConnectionGeometry, IfcElement* v6_RelatingElement, IfcElement* v7_RelatedElement, IfcTemplatedEntityList< IfcElement >::ptr v8_RealizingElements, boost::optional< std::string > v9_ConnectionType) : IfcRelConnectsElements((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_ConnectionGeometry)); e->setArgument(5,(v6_RelatingElement)); e->setArgument(6,(v7_RelatedElement)); e->setArgument(7,(v8_RealizingElements)->generalize()); if (v9_ConnectionType) { e->setArgument(8,(*v9_ConnectionType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcRelConnectsWithRealizingElements::IfcRelConnectsWithRealizingElements(IfcAbstractEntity* e) : IfcRelConnectsElements((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelConnectsWithRealizingElements)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelConnectsWithRealizingElements::IfcRelConnectsWithRealizingElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcConnectionGeometry* v5_ConnectionGeometry, IfcElement* v6_RelatingElement, IfcElement* v7_RelatedElement, IfcTemplatedEntityList< IfcElement >::ptr v8_RealizingElements, boost::optional< std::string > v9_ConnectionType) : IfcRelConnectsElements((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_ConnectionGeometry)); e->setArgument(5,(v6_RelatingElement)); e->setArgument(6,(v7_RelatedElement)); e->setArgument(7,(v8_RealizingElements)->generalize()); if (v9_ConnectionType) { e->setArgument(8,(*v9_ConnectionType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelContainedInSpatialStructure -IfcTemplatedEntityList< IfcProduct >::ptr IfcRelContainedInSpatialStructure::RelatedElements() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcRelContainedInSpatialStructure::setRelatedElements(IfcTemplatedEntityList< IfcProduct >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -IfcSpatialStructureElement* IfcRelContainedInSpatialStructure::RelatingStructure() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelContainedInSpatialStructure::setRelatingStructure(IfcSpatialStructureElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelContainedInSpatialStructure::is(Type::Enum v) const { return v == Type::IfcRelContainedInSpatialStructure || IfcRelConnects::is(v); } -Type::Enum IfcRelContainedInSpatialStructure::type() const { return Type::IfcRelContainedInSpatialStructure; } +IfcTemplatedEntityList< IfcProduct >::ptr IfcRelContainedInSpatialStructure::RelatedElements() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcRelContainedInSpatialStructure::setRelatedElements(IfcTemplatedEntityList< IfcProduct >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } +IfcSpatialStructureElement* IfcRelContainedInSpatialStructure::RelatingStructure() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelContainedInSpatialStructure::setRelatingStructure(IfcSpatialStructureElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelContainedInSpatialStructure::declaration() const { return *IfcRelContainedInSpatialStructure_type; } Type::Enum IfcRelContainedInSpatialStructure::Class() { return Type::IfcRelContainedInSpatialStructure; } -IfcRelContainedInSpatialStructure::IfcRelContainedInSpatialStructure(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelContainedInSpatialStructure)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelContainedInSpatialStructure::IfcRelContainedInSpatialStructure(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcProduct >::ptr v5_RelatedElements, IfcSpatialStructureElement* v6_RelatingStructure) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedElements)->generalize()); e->setArgument(5,(v6_RelatingStructure)); entity = e; EntityBuffer::Add(this); } +IfcRelContainedInSpatialStructure::IfcRelContainedInSpatialStructure(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelContainedInSpatialStructure)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelContainedInSpatialStructure::IfcRelContainedInSpatialStructure(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcProduct >::ptr v5_RelatedElements, IfcSpatialStructureElement* v6_RelatingStructure) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedElements)->generalize()); e->setArgument(5,(v6_RelatingStructure)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelCoversBldgElements -IfcElement* IfcRelCoversBldgElements::RelatingBuildingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelCoversBldgElements::setRelatingBuildingElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcTemplatedEntityList< IfcCovering >::ptr IfcRelCoversBldgElements::RelatedCoverings() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcRelCoversBldgElements::setRelatedCoverings(IfcTemplatedEntityList< IfcCovering >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v->generalize()); } -bool IfcRelCoversBldgElements::is(Type::Enum v) const { return v == Type::IfcRelCoversBldgElements || IfcRelConnects::is(v); } -Type::Enum IfcRelCoversBldgElements::type() const { return Type::IfcRelCoversBldgElements; } +IfcElement* IfcRelCoversBldgElements::RelatingBuildingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelCoversBldgElements::setRelatingBuildingElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcTemplatedEntityList< IfcCovering >::ptr IfcRelCoversBldgElements::RelatedCoverings() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcRelCoversBldgElements::setRelatedCoverings(IfcTemplatedEntityList< IfcCovering >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v->generalize()); } + + +const IfcParse::entity& IfcRelCoversBldgElements::declaration() const { return *IfcRelCoversBldgElements_type; } Type::Enum IfcRelCoversBldgElements::Class() { return Type::IfcRelCoversBldgElements; } -IfcRelCoversBldgElements::IfcRelCoversBldgElements(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelCoversBldgElements)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelCoversBldgElements::IfcRelCoversBldgElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingBuildingElement, IfcTemplatedEntityList< IfcCovering >::ptr v6_RelatedCoverings) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingBuildingElement)); e->setArgument(5,(v6_RelatedCoverings)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcRelCoversBldgElements::IfcRelCoversBldgElements(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelCoversBldgElements)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelCoversBldgElements::IfcRelCoversBldgElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingBuildingElement, IfcTemplatedEntityList< IfcCovering >::ptr v6_RelatedCoverings) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingBuildingElement)); e->setArgument(5,(v6_RelatedCoverings)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelCoversSpaces -IfcSpace* IfcRelCoversSpaces::RelatedSpace() const { return (IfcSpace*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelCoversSpaces::setRelatedSpace(IfcSpace* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcTemplatedEntityList< IfcCovering >::ptr IfcRelCoversSpaces::RelatedCoverings() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcRelCoversSpaces::setRelatedCoverings(IfcTemplatedEntityList< IfcCovering >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v->generalize()); } -bool IfcRelCoversSpaces::is(Type::Enum v) const { return v == Type::IfcRelCoversSpaces || IfcRelConnects::is(v); } -Type::Enum IfcRelCoversSpaces::type() const { return Type::IfcRelCoversSpaces; } +IfcSpace* IfcRelCoversSpaces::RelatedSpace() const { return (IfcSpace*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelCoversSpaces::setRelatedSpace(IfcSpace* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcTemplatedEntityList< IfcCovering >::ptr IfcRelCoversSpaces::RelatedCoverings() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcRelCoversSpaces::setRelatedCoverings(IfcTemplatedEntityList< IfcCovering >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v->generalize()); } + + +const IfcParse::entity& IfcRelCoversSpaces::declaration() const { return *IfcRelCoversSpaces_type; } Type::Enum IfcRelCoversSpaces::Class() { return Type::IfcRelCoversSpaces; } -IfcRelCoversSpaces::IfcRelCoversSpaces(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelCoversSpaces)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelCoversSpaces::IfcRelCoversSpaces(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpace* v5_RelatedSpace, IfcTemplatedEntityList< IfcCovering >::ptr v6_RelatedCoverings) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedSpace)); e->setArgument(5,(v6_RelatedCoverings)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcRelCoversSpaces::IfcRelCoversSpaces(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelCoversSpaces)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelCoversSpaces::IfcRelCoversSpaces(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpace* v5_RelatedSpace, IfcTemplatedEntityList< IfcCovering >::ptr v6_RelatedCoverings) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedSpace)); e->setArgument(5,(v6_RelatedCoverings)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelDecomposes -IfcObjectDefinition* IfcRelDecomposes::RelatingObject() const { return (IfcObjectDefinition*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelDecomposes::setRelatingObject(IfcObjectDefinition* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcTemplatedEntityList< IfcObjectDefinition >::ptr IfcRelDecomposes::RelatedObjects() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcRelDecomposes::setRelatedObjects(IfcTemplatedEntityList< IfcObjectDefinition >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v->generalize()); } -bool IfcRelDecomposes::is(Type::Enum v) const { return v == Type::IfcRelDecomposes || IfcRelationship::is(v); } -Type::Enum IfcRelDecomposes::type() const { return Type::IfcRelDecomposes; } +IfcObjectDefinition* IfcRelDecomposes::RelatingObject() const { return (IfcObjectDefinition*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelDecomposes::setRelatingObject(IfcObjectDefinition* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcTemplatedEntityList< IfcObjectDefinition >::ptr IfcRelDecomposes::RelatedObjects() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcRelDecomposes::setRelatedObjects(IfcTemplatedEntityList< IfcObjectDefinition >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v->generalize()); } + + +const IfcParse::entity& IfcRelDecomposes::declaration() const { return *IfcRelDecomposes_type; } Type::Enum IfcRelDecomposes::Class() { return Type::IfcRelDecomposes; } -IfcRelDecomposes::IfcRelDecomposes(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDecomposes)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelDecomposes::IfcRelDecomposes(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcObjectDefinition* v5_RelatingObject, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v6_RelatedObjects) : IfcRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingObject)); e->setArgument(5,(v6_RelatedObjects)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcRelDecomposes::IfcRelDecomposes(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDecomposes)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelDecomposes::IfcRelDecomposes(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcObjectDefinition* v5_RelatingObject, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v6_RelatedObjects) : IfcRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingObject)); e->setArgument(5,(v6_RelatedObjects)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelDefines -IfcTemplatedEntityList< IfcObject >::ptr IfcRelDefines::RelatedObjects() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcRelDefines::setRelatedObjects(IfcTemplatedEntityList< IfcObject >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -bool IfcRelDefines::is(Type::Enum v) const { return v == Type::IfcRelDefines || IfcRelationship::is(v); } -Type::Enum IfcRelDefines::type() const { return Type::IfcRelDefines; } +IfcTemplatedEntityList< IfcObject >::ptr IfcRelDefines::RelatedObjects() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcRelDefines::setRelatedObjects(IfcTemplatedEntityList< IfcObject >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } + + +const IfcParse::entity& IfcRelDefines::declaration() const { return *IfcRelDefines_type; } Type::Enum IfcRelDefines::Class() { return Type::IfcRelDefines; } -IfcRelDefines::IfcRelDefines(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDefines)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelDefines::IfcRelDefines(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects) : IfcRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcRelDefines::IfcRelDefines(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDefines)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelDefines::IfcRelDefines(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects) : IfcRelationship((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelDefinesByProperties -IfcPropertySetDefinition* IfcRelDefinesByProperties::RelatingPropertyDefinition() const { return (IfcPropertySetDefinition*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelDefinesByProperties::setRelatingPropertyDefinition(IfcPropertySetDefinition* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelDefinesByProperties::is(Type::Enum v) const { return v == Type::IfcRelDefinesByProperties || IfcRelDefines::is(v); } -Type::Enum IfcRelDefinesByProperties::type() const { return Type::IfcRelDefinesByProperties; } +IfcPropertySetDefinition* IfcRelDefinesByProperties::RelatingPropertyDefinition() const { return (IfcPropertySetDefinition*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelDefinesByProperties::setRelatingPropertyDefinition(IfcPropertySetDefinition* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelDefinesByProperties::declaration() const { return *IfcRelDefinesByProperties_type; } Type::Enum IfcRelDefinesByProperties::Class() { return Type::IfcRelDefinesByProperties; } -IfcRelDefinesByProperties::IfcRelDefinesByProperties(IfcAbstractEntity* e) : IfcRelDefines((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDefinesByProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelDefinesByProperties::IfcRelDefinesByProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcPropertySetDefinition* v6_RelatingPropertyDefinition) : IfcRelDefines((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingPropertyDefinition)); entity = e; EntityBuffer::Add(this); } +IfcRelDefinesByProperties::IfcRelDefinesByProperties(IfcAbstractEntity* e) : IfcRelDefines((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDefinesByProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelDefinesByProperties::IfcRelDefinesByProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcPropertySetDefinition* v6_RelatingPropertyDefinition) : IfcRelDefines((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingPropertyDefinition)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelDefinesByType -IfcTypeObject* IfcRelDefinesByType::RelatingType() const { return (IfcTypeObject*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelDefinesByType::setRelatingType(IfcTypeObject* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelDefinesByType::is(Type::Enum v) const { return v == Type::IfcRelDefinesByType || IfcRelDefines::is(v); } -Type::Enum IfcRelDefinesByType::type() const { return Type::IfcRelDefinesByType; } +IfcTypeObject* IfcRelDefinesByType::RelatingType() const { return (IfcTypeObject*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelDefinesByType::setRelatingType(IfcTypeObject* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelDefinesByType::declaration() const { return *IfcRelDefinesByType_type; } Type::Enum IfcRelDefinesByType::Class() { return Type::IfcRelDefinesByType; } -IfcRelDefinesByType::IfcRelDefinesByType(IfcAbstractEntity* e) : IfcRelDefines((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDefinesByType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelDefinesByType::IfcRelDefinesByType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcTypeObject* v6_RelatingType) : IfcRelDefines((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingType)); entity = e; EntityBuffer::Add(this); } +IfcRelDefinesByType::IfcRelDefinesByType(IfcAbstractEntity* e) : IfcRelDefines((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDefinesByType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelDefinesByType::IfcRelDefinesByType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcTypeObject* v6_RelatingType) : IfcRelDefines((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelFillsElement -IfcOpeningElement* IfcRelFillsElement::RelatingOpeningElement() const { return (IfcOpeningElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelFillsElement::setRelatingOpeningElement(IfcOpeningElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcElement* IfcRelFillsElement::RelatedBuildingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelFillsElement::setRelatedBuildingElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelFillsElement::is(Type::Enum v) const { return v == Type::IfcRelFillsElement || IfcRelConnects::is(v); } -Type::Enum IfcRelFillsElement::type() const { return Type::IfcRelFillsElement; } +IfcOpeningElement* IfcRelFillsElement::RelatingOpeningElement() const { return (IfcOpeningElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelFillsElement::setRelatingOpeningElement(IfcOpeningElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcElement* IfcRelFillsElement::RelatedBuildingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelFillsElement::setRelatedBuildingElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelFillsElement::declaration() const { return *IfcRelFillsElement_type; } Type::Enum IfcRelFillsElement::Class() { return Type::IfcRelFillsElement; } -IfcRelFillsElement::IfcRelFillsElement(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelFillsElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelFillsElement::IfcRelFillsElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcOpeningElement* v5_RelatingOpeningElement, IfcElement* v6_RelatedBuildingElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingOpeningElement)); e->setArgument(5,(v6_RelatedBuildingElement)); entity = e; EntityBuffer::Add(this); } +IfcRelFillsElement::IfcRelFillsElement(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelFillsElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelFillsElement::IfcRelFillsElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcOpeningElement* v5_RelatingOpeningElement, IfcElement* v6_RelatedBuildingElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingOpeningElement)); e->setArgument(5,(v6_RelatedBuildingElement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelFlowControlElements -IfcTemplatedEntityList< IfcDistributionControlElement >::ptr IfcRelFlowControlElements::RelatedControlElements() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcRelFlowControlElements::setRelatedControlElements(IfcTemplatedEntityList< IfcDistributionControlElement >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -IfcDistributionFlowElement* IfcRelFlowControlElements::RelatingFlowElement() const { return (IfcDistributionFlowElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelFlowControlElements::setRelatingFlowElement(IfcDistributionFlowElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelFlowControlElements::is(Type::Enum v) const { return v == Type::IfcRelFlowControlElements || IfcRelConnects::is(v); } -Type::Enum IfcRelFlowControlElements::type() const { return Type::IfcRelFlowControlElements; } +IfcTemplatedEntityList< IfcDistributionControlElement >::ptr IfcRelFlowControlElements::RelatedControlElements() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcRelFlowControlElements::setRelatedControlElements(IfcTemplatedEntityList< IfcDistributionControlElement >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } +IfcDistributionFlowElement* IfcRelFlowControlElements::RelatingFlowElement() const { return (IfcDistributionFlowElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelFlowControlElements::setRelatingFlowElement(IfcDistributionFlowElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelFlowControlElements::declaration() const { return *IfcRelFlowControlElements_type; } Type::Enum IfcRelFlowControlElements::Class() { return Type::IfcRelFlowControlElements; } -IfcRelFlowControlElements::IfcRelFlowControlElements(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelFlowControlElements)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelFlowControlElements::IfcRelFlowControlElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcDistributionControlElement >::ptr v5_RelatedControlElements, IfcDistributionFlowElement* v6_RelatingFlowElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedControlElements)->generalize()); e->setArgument(5,(v6_RelatingFlowElement)); entity = e; EntityBuffer::Add(this); } +IfcRelFlowControlElements::IfcRelFlowControlElements(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelFlowControlElements)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelFlowControlElements::IfcRelFlowControlElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcDistributionControlElement >::ptr v5_RelatedControlElements, IfcDistributionFlowElement* v6_RelatingFlowElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedControlElements)->generalize()); e->setArgument(5,(v6_RelatingFlowElement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelInteractionRequirements -bool IfcRelInteractionRequirements::hasDailyInteraction() const { return !entity->getArgument(4)->isNull(); } -double IfcRelInteractionRequirements::DailyInteraction() const { return *entity->getArgument(4); } -void IfcRelInteractionRequirements::setDailyInteraction(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcRelInteractionRequirements::hasImportanceRating() const { return !entity->getArgument(5)->isNull(); } -double IfcRelInteractionRequirements::ImportanceRating() const { return *entity->getArgument(5); } -void IfcRelInteractionRequirements::setImportanceRating(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelInteractionRequirements::hasLocationOfInteraction() const { return !entity->getArgument(6)->isNull(); } -IfcSpatialStructureElement* IfcRelInteractionRequirements::LocationOfInteraction() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelInteractionRequirements::setLocationOfInteraction(IfcSpatialStructureElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcSpaceProgram* IfcRelInteractionRequirements::RelatedSpaceProgram() const { return (IfcSpaceProgram*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcRelInteractionRequirements::setRelatedSpaceProgram(IfcSpaceProgram* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcSpaceProgram* IfcRelInteractionRequirements::RelatingSpaceProgram() const { return (IfcSpaceProgram*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcRelInteractionRequirements::setRelatingSpaceProgram(IfcSpaceProgram* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcRelInteractionRequirements::is(Type::Enum v) const { return v == Type::IfcRelInteractionRequirements || IfcRelConnects::is(v); } -Type::Enum IfcRelInteractionRequirements::type() const { return Type::IfcRelInteractionRequirements; } +bool IfcRelInteractionRequirements::hasDailyInteraction() const { return !data_->getArgument(4)->isNull(); } +double IfcRelInteractionRequirements::DailyInteraction() const { return *data_->getArgument(4); } +void IfcRelInteractionRequirements::setDailyInteraction(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcRelInteractionRequirements::hasImportanceRating() const { return !data_->getArgument(5)->isNull(); } +double IfcRelInteractionRequirements::ImportanceRating() const { return *data_->getArgument(5); } +void IfcRelInteractionRequirements::setImportanceRating(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcRelInteractionRequirements::hasLocationOfInteraction() const { return !data_->getArgument(6)->isNull(); } +IfcSpatialStructureElement* IfcRelInteractionRequirements::LocationOfInteraction() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelInteractionRequirements::setLocationOfInteraction(IfcSpatialStructureElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +IfcSpaceProgram* IfcRelInteractionRequirements::RelatedSpaceProgram() const { return (IfcSpaceProgram*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcRelInteractionRequirements::setRelatedSpaceProgram(IfcSpaceProgram* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +IfcSpaceProgram* IfcRelInteractionRequirements::RelatingSpaceProgram() const { return (IfcSpaceProgram*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcRelInteractionRequirements::setRelatingSpaceProgram(IfcSpaceProgram* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcRelInteractionRequirements::declaration() const { return *IfcRelInteractionRequirements_type; } Type::Enum IfcRelInteractionRequirements::Class() { return Type::IfcRelInteractionRequirements; } -IfcRelInteractionRequirements::IfcRelInteractionRequirements(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelInteractionRequirements)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelInteractionRequirements::IfcRelInteractionRequirements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_DailyInteraction, boost::optional< double > v6_ImportanceRating, IfcSpatialStructureElement* v7_LocationOfInteraction, IfcSpaceProgram* v8_RelatedSpaceProgram, IfcSpaceProgram* v9_RelatingSpaceProgram) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_DailyInteraction) { e->setArgument(4,(*v5_DailyInteraction)); } else { e->setArgument(4); } if (v6_ImportanceRating) { e->setArgument(5,(*v6_ImportanceRating)); } else { e->setArgument(5); } e->setArgument(6,(v7_LocationOfInteraction)); e->setArgument(7,(v8_RelatedSpaceProgram)); e->setArgument(8,(v9_RelatingSpaceProgram)); entity = e; EntityBuffer::Add(this); } +IfcRelInteractionRequirements::IfcRelInteractionRequirements(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelInteractionRequirements)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelInteractionRequirements::IfcRelInteractionRequirements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_DailyInteraction, boost::optional< double > v6_ImportanceRating, IfcSpatialStructureElement* v7_LocationOfInteraction, IfcSpaceProgram* v8_RelatedSpaceProgram, IfcSpaceProgram* v9_RelatingSpaceProgram) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_DailyInteraction) { e->setArgument(4,(*v5_DailyInteraction)); } else { e->setArgument(4); } if (v6_ImportanceRating) { e->setArgument(5,(*v6_ImportanceRating)); } else { e->setArgument(5); } e->setArgument(6,(v7_LocationOfInteraction)); e->setArgument(7,(v8_RelatedSpaceProgram)); e->setArgument(8,(v9_RelatingSpaceProgram)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelNests -bool IfcRelNests::is(Type::Enum v) const { return v == Type::IfcRelNests || IfcRelDecomposes::is(v); } -Type::Enum IfcRelNests::type() const { return Type::IfcRelNests; } + + +const IfcParse::entity& IfcRelNests::declaration() const { return *IfcRelNests_type; } Type::Enum IfcRelNests::Class() { return Type::IfcRelNests; } -IfcRelNests::IfcRelNests(IfcAbstractEntity* e) : IfcRelDecomposes((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelNests)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelNests::IfcRelNests(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcObjectDefinition* v5_RelatingObject, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v6_RelatedObjects) : IfcRelDecomposes((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingObject)); e->setArgument(5,(v6_RelatedObjects)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcRelNests::IfcRelNests(IfcAbstractEntity* e) : IfcRelDecomposes((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelNests)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelNests::IfcRelNests(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcObjectDefinition* v5_RelatingObject, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v6_RelatedObjects) : IfcRelDecomposes((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingObject)); e->setArgument(5,(v6_RelatedObjects)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelOccupiesSpaces -bool IfcRelOccupiesSpaces::is(Type::Enum v) const { return v == Type::IfcRelOccupiesSpaces || IfcRelAssignsToActor::is(v); } -Type::Enum IfcRelOccupiesSpaces::type() const { return Type::IfcRelOccupiesSpaces; } + + +const IfcParse::entity& IfcRelOccupiesSpaces::declaration() const { return *IfcRelOccupiesSpaces_type; } Type::Enum IfcRelOccupiesSpaces::Class() { return Type::IfcRelOccupiesSpaces; } -IfcRelOccupiesSpaces::IfcRelOccupiesSpaces(IfcAbstractEntity* e) : IfcRelAssignsToActor((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelOccupiesSpaces)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelOccupiesSpaces::IfcRelOccupiesSpaces(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcActor* v7_RelatingActor, IfcActorRole* v8_ActingRole) : IfcRelAssignsToActor((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingActor)); e->setArgument(7,(v8_ActingRole)); entity = e; EntityBuffer::Add(this); } +IfcRelOccupiesSpaces::IfcRelOccupiesSpaces(IfcAbstractEntity* e) : IfcRelAssignsToActor((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelOccupiesSpaces)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelOccupiesSpaces::IfcRelOccupiesSpaces(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcActor* v7_RelatingActor, IfcActorRole* v8_ActingRole) : IfcRelAssignsToActor((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingActor)); e->setArgument(7,(v8_ActingRole)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelOverridesProperties -IfcTemplatedEntityList< IfcProperty >::ptr IfcRelOverridesProperties::OverridingProperties() const { IfcEntityList::ptr es = *entity->getArgument(6); return es->as(); } -void IfcRelOverridesProperties::setOverridingProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v->generalize()); } -bool IfcRelOverridesProperties::is(Type::Enum v) const { return v == Type::IfcRelOverridesProperties || IfcRelDefinesByProperties::is(v); } -Type::Enum IfcRelOverridesProperties::type() const { return Type::IfcRelOverridesProperties; } +IfcTemplatedEntityList< IfcProperty >::ptr IfcRelOverridesProperties::OverridingProperties() const { IfcEntityList::ptr es = *data_->getArgument(6); return es->as(); } +void IfcRelOverridesProperties::setOverridingProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v->generalize()); } + + +const IfcParse::entity& IfcRelOverridesProperties::declaration() const { return *IfcRelOverridesProperties_type; } Type::Enum IfcRelOverridesProperties::Class() { return Type::IfcRelOverridesProperties; } -IfcRelOverridesProperties::IfcRelOverridesProperties(IfcAbstractEntity* e) : IfcRelDefinesByProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelOverridesProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelOverridesProperties::IfcRelOverridesProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcPropertySetDefinition* v6_RelatingPropertyDefinition, IfcTemplatedEntityList< IfcProperty >::ptr v7_OverridingProperties) : IfcRelDefinesByProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingPropertyDefinition)); e->setArgument(6,(v7_OverridingProperties)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcRelOverridesProperties::IfcRelOverridesProperties(IfcAbstractEntity* e) : IfcRelDefinesByProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelOverridesProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelOverridesProperties::IfcRelOverridesProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcPropertySetDefinition* v6_RelatingPropertyDefinition, IfcTemplatedEntityList< IfcProperty >::ptr v7_OverridingProperties) : IfcRelDefinesByProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); e->setArgument(5,(v6_RelatingPropertyDefinition)); e->setArgument(6,(v7_OverridingProperties)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelProjectsElement -IfcElement* IfcRelProjectsElement::RelatingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelProjectsElement::setRelatingElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcFeatureElementAddition* IfcRelProjectsElement::RelatedFeatureElement() const { return (IfcFeatureElementAddition*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelProjectsElement::setRelatedFeatureElement(IfcFeatureElementAddition* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelProjectsElement::is(Type::Enum v) const { return v == Type::IfcRelProjectsElement || IfcRelConnects::is(v); } -Type::Enum IfcRelProjectsElement::type() const { return Type::IfcRelProjectsElement; } +IfcElement* IfcRelProjectsElement::RelatingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelProjectsElement::setRelatingElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcFeatureElementAddition* IfcRelProjectsElement::RelatedFeatureElement() const { return (IfcFeatureElementAddition*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelProjectsElement::setRelatedFeatureElement(IfcFeatureElementAddition* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelProjectsElement::declaration() const { return *IfcRelProjectsElement_type; } Type::Enum IfcRelProjectsElement::Class() { return Type::IfcRelProjectsElement; } -IfcRelProjectsElement::IfcRelProjectsElement(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelProjectsElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelProjectsElement::IfcRelProjectsElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingElement, IfcFeatureElementAddition* v6_RelatedFeatureElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingElement)); e->setArgument(5,(v6_RelatedFeatureElement)); entity = e; EntityBuffer::Add(this); } +IfcRelProjectsElement::IfcRelProjectsElement(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelProjectsElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelProjectsElement::IfcRelProjectsElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingElement, IfcFeatureElementAddition* v6_RelatedFeatureElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingElement)); e->setArgument(5,(v6_RelatedFeatureElement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelReferencedInSpatialStructure -IfcTemplatedEntityList< IfcProduct >::ptr IfcRelReferencedInSpatialStructure::RelatedElements() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcRelReferencedInSpatialStructure::setRelatedElements(IfcTemplatedEntityList< IfcProduct >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -IfcSpatialStructureElement* IfcRelReferencedInSpatialStructure::RelatingStructure() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelReferencedInSpatialStructure::setRelatingStructure(IfcSpatialStructureElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelReferencedInSpatialStructure::is(Type::Enum v) const { return v == Type::IfcRelReferencedInSpatialStructure || IfcRelConnects::is(v); } -Type::Enum IfcRelReferencedInSpatialStructure::type() const { return Type::IfcRelReferencedInSpatialStructure; } +IfcTemplatedEntityList< IfcProduct >::ptr IfcRelReferencedInSpatialStructure::RelatedElements() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcRelReferencedInSpatialStructure::setRelatedElements(IfcTemplatedEntityList< IfcProduct >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } +IfcSpatialStructureElement* IfcRelReferencedInSpatialStructure::RelatingStructure() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelReferencedInSpatialStructure::setRelatingStructure(IfcSpatialStructureElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelReferencedInSpatialStructure::declaration() const { return *IfcRelReferencedInSpatialStructure_type; } Type::Enum IfcRelReferencedInSpatialStructure::Class() { return Type::IfcRelReferencedInSpatialStructure; } -IfcRelReferencedInSpatialStructure::IfcRelReferencedInSpatialStructure(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelReferencedInSpatialStructure)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelReferencedInSpatialStructure::IfcRelReferencedInSpatialStructure(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcProduct >::ptr v5_RelatedElements, IfcSpatialStructureElement* v6_RelatingStructure) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedElements)->generalize()); e->setArgument(5,(v6_RelatingStructure)); entity = e; EntityBuffer::Add(this); } +IfcRelReferencedInSpatialStructure::IfcRelReferencedInSpatialStructure(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelReferencedInSpatialStructure)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelReferencedInSpatialStructure::IfcRelReferencedInSpatialStructure(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcProduct >::ptr v5_RelatedElements, IfcSpatialStructureElement* v6_RelatingStructure) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedElements)->generalize()); e->setArgument(5,(v6_RelatingStructure)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelSchedulesCostItems -bool IfcRelSchedulesCostItems::is(Type::Enum v) const { return v == Type::IfcRelSchedulesCostItems || IfcRelAssignsToControl::is(v); } -Type::Enum IfcRelSchedulesCostItems::type() const { return Type::IfcRelSchedulesCostItems; } + + +const IfcParse::entity& IfcRelSchedulesCostItems::declaration() const { return *IfcRelSchedulesCostItems_type; } Type::Enum IfcRelSchedulesCostItems::Class() { return Type::IfcRelSchedulesCostItems; } -IfcRelSchedulesCostItems::IfcRelSchedulesCostItems(IfcAbstractEntity* e) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelSchedulesCostItems)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelSchedulesCostItems::IfcRelSchedulesCostItems(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingControl)); entity = e; EntityBuffer::Add(this); } +IfcRelSchedulesCostItems::IfcRelSchedulesCostItems(IfcAbstractEntity* e) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelSchedulesCostItems)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelSchedulesCostItems::IfcRelSchedulesCostItems(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl) : IfcRelAssignsToControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) { e->setArgument(5,*v6_RelatedObjectsType,IfcObjectTypeEnum::ToString(*v6_RelatedObjectsType)); } else { e->setArgument(5); } e->setArgument(6,(v7_RelatingControl)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelSequence -IfcProcess* IfcRelSequence::RelatingProcess() const { return (IfcProcess*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelSequence::setRelatingProcess(IfcProcess* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcProcess* IfcRelSequence::RelatedProcess() const { return (IfcProcess*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelSequence::setRelatedProcess(IfcProcess* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcRelSequence::TimeLag() const { return *entity->getArgument(6); } -void IfcRelSequence::setTimeLag(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcSequenceEnum::IfcSequenceEnum IfcRelSequence::SequenceType() const { return IfcSequenceEnum::FromString(*entity->getArgument(7)); } -void IfcRelSequence::setSequenceType(IfcSequenceEnum::IfcSequenceEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcSequenceEnum::ToString(v)); } -bool IfcRelSequence::is(Type::Enum v) const { return v == Type::IfcRelSequence || IfcRelConnects::is(v); } -Type::Enum IfcRelSequence::type() const { return Type::IfcRelSequence; } +IfcProcess* IfcRelSequence::RelatingProcess() const { return (IfcProcess*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelSequence::setRelatingProcess(IfcProcess* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcProcess* IfcRelSequence::RelatedProcess() const { return (IfcProcess*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelSequence::setRelatedProcess(IfcProcess* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcRelSequence::TimeLag() const { return *data_->getArgument(6); } +void IfcRelSequence::setTimeLag(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +IfcSequenceEnum::IfcSequenceEnum IfcRelSequence::SequenceType() const { return IfcSequenceEnum::FromString(*data_->getArgument(7)); } +void IfcRelSequence::setSequenceType(IfcSequenceEnum::IfcSequenceEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcSequenceEnum::ToString(v)); } + + +const IfcParse::entity& IfcRelSequence::declaration() const { return *IfcRelSequence_type; } Type::Enum IfcRelSequence::Class() { return Type::IfcRelSequence; } -IfcRelSequence::IfcRelSequence(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelSequence)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelSequence::IfcRelSequence(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcProcess* v5_RelatingProcess, IfcProcess* v6_RelatedProcess, double v7_TimeLag, IfcSequenceEnum::IfcSequenceEnum v8_SequenceType) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingProcess)); e->setArgument(5,(v6_RelatedProcess)); e->setArgument(6,(v7_TimeLag)); e->setArgument(7,v8_SequenceType,IfcSequenceEnum::ToString(v8_SequenceType)); entity = e; EntityBuffer::Add(this); } +IfcRelSequence::IfcRelSequence(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelSequence)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelSequence::IfcRelSequence(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcProcess* v5_RelatingProcess, IfcProcess* v6_RelatedProcess, double v7_TimeLag, IfcSequenceEnum::IfcSequenceEnum v8_SequenceType) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingProcess)); e->setArgument(5,(v6_RelatedProcess)); e->setArgument(6,(v7_TimeLag)); e->setArgument(7,v8_SequenceType,IfcSequenceEnum::ToString(v8_SequenceType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelServicesBuildings -IfcSystem* IfcRelServicesBuildings::RelatingSystem() const { return (IfcSystem*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelServicesBuildings::setRelatingSystem(IfcSystem* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcTemplatedEntityList< IfcSpatialStructureElement >::ptr IfcRelServicesBuildings::RelatedBuildings() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcRelServicesBuildings::setRelatedBuildings(IfcTemplatedEntityList< IfcSpatialStructureElement >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v->generalize()); } -bool IfcRelServicesBuildings::is(Type::Enum v) const { return v == Type::IfcRelServicesBuildings || IfcRelConnects::is(v); } -Type::Enum IfcRelServicesBuildings::type() const { return Type::IfcRelServicesBuildings; } +IfcSystem* IfcRelServicesBuildings::RelatingSystem() const { return (IfcSystem*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelServicesBuildings::setRelatingSystem(IfcSystem* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcTemplatedEntityList< IfcSpatialStructureElement >::ptr IfcRelServicesBuildings::RelatedBuildings() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcRelServicesBuildings::setRelatedBuildings(IfcTemplatedEntityList< IfcSpatialStructureElement >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v->generalize()); } + + +const IfcParse::entity& IfcRelServicesBuildings::declaration() const { return *IfcRelServicesBuildings_type; } Type::Enum IfcRelServicesBuildings::Class() { return Type::IfcRelServicesBuildings; } -IfcRelServicesBuildings::IfcRelServicesBuildings(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelServicesBuildings)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelServicesBuildings::IfcRelServicesBuildings(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSystem* v5_RelatingSystem, IfcTemplatedEntityList< IfcSpatialStructureElement >::ptr v6_RelatedBuildings) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingSystem)); e->setArgument(5,(v6_RelatedBuildings)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcRelServicesBuildings::IfcRelServicesBuildings(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelServicesBuildings)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelServicesBuildings::IfcRelServicesBuildings(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSystem* v5_RelatingSystem, IfcTemplatedEntityList< IfcSpatialStructureElement >::ptr v6_RelatedBuildings) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingSystem)); e->setArgument(5,(v6_RelatedBuildings)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelSpaceBoundary -IfcSpace* IfcRelSpaceBoundary::RelatingSpace() const { return (IfcSpace*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelSpaceBoundary::setRelatingSpace(IfcSpace* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcRelSpaceBoundary::hasRelatedBuildingElement() const { return !entity->getArgument(5)->isNull(); } -IfcElement* IfcRelSpaceBoundary::RelatedBuildingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelSpaceBoundary::setRelatedBuildingElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelSpaceBoundary::hasConnectionGeometry() const { return !entity->getArgument(6)->isNull(); } -IfcConnectionGeometry* IfcRelSpaceBoundary::ConnectionGeometry() const { return (IfcConnectionGeometry*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelSpaceBoundary::setConnectionGeometry(IfcConnectionGeometry* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum IfcRelSpaceBoundary::PhysicalOrVirtualBoundary() const { return IfcPhysicalOrVirtualEnum::FromString(*entity->getArgument(7)); } -void IfcRelSpaceBoundary::setPhysicalOrVirtualBoundary(IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcPhysicalOrVirtualEnum::ToString(v)); } -IfcInternalOrExternalEnum::IfcInternalOrExternalEnum IfcRelSpaceBoundary::InternalOrExternalBoundary() const { return IfcInternalOrExternalEnum::FromString(*entity->getArgument(8)); } -void IfcRelSpaceBoundary::setInternalOrExternalBoundary(IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcInternalOrExternalEnum::ToString(v)); } -bool IfcRelSpaceBoundary::is(Type::Enum v) const { return v == Type::IfcRelSpaceBoundary || IfcRelConnects::is(v); } -Type::Enum IfcRelSpaceBoundary::type() const { return Type::IfcRelSpaceBoundary; } +IfcSpace* IfcRelSpaceBoundary::RelatingSpace() const { return (IfcSpace*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelSpaceBoundary::setRelatingSpace(IfcSpace* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcRelSpaceBoundary::hasRelatedBuildingElement() const { return !data_->getArgument(5)->isNull(); } +IfcElement* IfcRelSpaceBoundary::RelatedBuildingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelSpaceBoundary::setRelatedBuildingElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcRelSpaceBoundary::hasConnectionGeometry() const { return !data_->getArgument(6)->isNull(); } +IfcConnectionGeometry* IfcRelSpaceBoundary::ConnectionGeometry() const { return (IfcConnectionGeometry*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelSpaceBoundary::setConnectionGeometry(IfcConnectionGeometry* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum IfcRelSpaceBoundary::PhysicalOrVirtualBoundary() const { return IfcPhysicalOrVirtualEnum::FromString(*data_->getArgument(7)); } +void IfcRelSpaceBoundary::setPhysicalOrVirtualBoundary(IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcPhysicalOrVirtualEnum::ToString(v)); } +IfcInternalOrExternalEnum::IfcInternalOrExternalEnum IfcRelSpaceBoundary::InternalOrExternalBoundary() const { return IfcInternalOrExternalEnum::FromString(*data_->getArgument(8)); } +void IfcRelSpaceBoundary::setInternalOrExternalBoundary(IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcInternalOrExternalEnum::ToString(v)); } + + +const IfcParse::entity& IfcRelSpaceBoundary::declaration() const { return *IfcRelSpaceBoundary_type; } Type::Enum IfcRelSpaceBoundary::Class() { return Type::IfcRelSpaceBoundary; } -IfcRelSpaceBoundary::IfcRelSpaceBoundary(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelSpaceBoundary)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelSpaceBoundary::IfcRelSpaceBoundary(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpace* v5_RelatingSpace, IfcElement* v6_RelatedBuildingElement, IfcConnectionGeometry* v7_ConnectionGeometry, IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v8_PhysicalOrVirtualBoundary, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v9_InternalOrExternalBoundary) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingSpace)); e->setArgument(5,(v6_RelatedBuildingElement)); e->setArgument(6,(v7_ConnectionGeometry)); e->setArgument(7,v8_PhysicalOrVirtualBoundary,IfcPhysicalOrVirtualEnum::ToString(v8_PhysicalOrVirtualBoundary)); e->setArgument(8,v9_InternalOrExternalBoundary,IfcInternalOrExternalEnum::ToString(v9_InternalOrExternalBoundary)); entity = e; EntityBuffer::Add(this); } +IfcRelSpaceBoundary::IfcRelSpaceBoundary(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelSpaceBoundary)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelSpaceBoundary::IfcRelSpaceBoundary(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpace* v5_RelatingSpace, IfcElement* v6_RelatedBuildingElement, IfcConnectionGeometry* v7_ConnectionGeometry, IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v8_PhysicalOrVirtualBoundary, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v9_InternalOrExternalBoundary) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingSpace)); e->setArgument(5,(v6_RelatedBuildingElement)); e->setArgument(6,(v7_ConnectionGeometry)); e->setArgument(7,v8_PhysicalOrVirtualBoundary,IfcPhysicalOrVirtualEnum::ToString(v8_PhysicalOrVirtualBoundary)); e->setArgument(8,v9_InternalOrExternalBoundary,IfcInternalOrExternalEnum::ToString(v9_InternalOrExternalBoundary)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelVoidsElement -IfcElement* IfcRelVoidsElement::RelatingBuildingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelVoidsElement::setRelatingBuildingElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcFeatureElementSubtraction* IfcRelVoidsElement::RelatedOpeningElement() const { return (IfcFeatureElementSubtraction*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelVoidsElement::setRelatedOpeningElement(IfcFeatureElementSubtraction* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelVoidsElement::is(Type::Enum v) const { return v == Type::IfcRelVoidsElement || IfcRelConnects::is(v); } -Type::Enum IfcRelVoidsElement::type() const { return Type::IfcRelVoidsElement; } +IfcElement* IfcRelVoidsElement::RelatingBuildingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelVoidsElement::setRelatingBuildingElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcFeatureElementSubtraction* IfcRelVoidsElement::RelatedOpeningElement() const { return (IfcFeatureElementSubtraction*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelVoidsElement::setRelatedOpeningElement(IfcFeatureElementSubtraction* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelVoidsElement::declaration() const { return *IfcRelVoidsElement_type; } Type::Enum IfcRelVoidsElement::Class() { return Type::IfcRelVoidsElement; } -IfcRelVoidsElement::IfcRelVoidsElement(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelVoidsElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelVoidsElement::IfcRelVoidsElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingBuildingElement, IfcFeatureElementSubtraction* v6_RelatedOpeningElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingBuildingElement)); e->setArgument(5,(v6_RelatedOpeningElement)); entity = e; EntityBuffer::Add(this); } +IfcRelVoidsElement::IfcRelVoidsElement(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelVoidsElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelVoidsElement::IfcRelVoidsElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingBuildingElement, IfcFeatureElementSubtraction* v6_RelatedOpeningElement) : IfcRelConnects((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_RelatingBuildingElement)); e->setArgument(5,(v6_RelatedOpeningElement)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelationship -bool IfcRelationship::is(Type::Enum v) const { return v == Type::IfcRelationship || IfcRoot::is(v); } -Type::Enum IfcRelationship::type() const { return Type::IfcRelationship; } + + +const IfcParse::entity& IfcRelationship::declaration() const { return *IfcRelationship_type; } Type::Enum IfcRelationship::Class() { return Type::IfcRelationship; } -IfcRelationship::IfcRelationship(IfcAbstractEntity* e) : IfcRoot((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelationship::IfcRelationship(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRoot((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcRelationship::IfcRelationship(IfcAbstractEntity* e) : IfcRoot((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelationship::IfcRelationship(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRoot((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelaxation -double IfcRelaxation::RelaxationValue() const { return *entity->getArgument(0); } -void IfcRelaxation::setRelaxationValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcRelaxation::InitialStress() const { return *entity->getArgument(1); } -void IfcRelaxation::setInitialStress(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcRelaxation::is(Type::Enum v) const { return v == Type::IfcRelaxation; } -Type::Enum IfcRelaxation::type() const { return Type::IfcRelaxation; } +double IfcRelaxation::RelaxationValue() const { return *data_->getArgument(0); } +void IfcRelaxation::setRelaxationValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcRelaxation::InitialStress() const { return *data_->getArgument(1); } +void IfcRelaxation::setInitialStress(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcRelaxation::declaration() const { return *IfcRelaxation_type; } Type::Enum IfcRelaxation::Class() { return Type::IfcRelaxation; } -IfcRelaxation::IfcRelaxation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRelaxation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelaxation::IfcRelaxation(double v1_RelaxationValue, double v2_InitialStress) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelaxationValue)); e->setArgument(1,(v2_InitialStress)); entity = e; EntityBuffer::Add(this); } +IfcRelaxation::IfcRelaxation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRelaxation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelaxation::IfcRelaxation(double v1_RelaxationValue, double v2_InitialStress) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RelaxationValue)); e->setArgument(1,(v2_InitialStress)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRepresentation -IfcRepresentationContext* IfcRepresentation::ContextOfItems() const { return (IfcRepresentationContext*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcRepresentation::setContextOfItems(IfcRepresentationContext* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcRepresentation::hasRepresentationIdentifier() const { return !entity->getArgument(1)->isNull(); } -std::string IfcRepresentation::RepresentationIdentifier() const { return *entity->getArgument(1); } -void IfcRepresentation::setRepresentationIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcRepresentation::hasRepresentationType() const { return !entity->getArgument(2)->isNull(); } -std::string IfcRepresentation::RepresentationType() const { return *entity->getArgument(2); } -void IfcRepresentation::setRepresentationType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcTemplatedEntityList< IfcRepresentationItem >::ptr IfcRepresentation::Items() const { IfcEntityList::ptr es = *entity->getArgument(3); return es->as(); } -void IfcRepresentation::setItems(IfcTemplatedEntityList< IfcRepresentationItem >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v->generalize()); } -IfcRepresentationMap::list::ptr IfcRepresentation::RepresentationMap() const { return entity->getInverse(Type::IfcRepresentationMap, 1)->as(); } -IfcPresentationLayerAssignment::list::ptr IfcRepresentation::LayerAssignments() const { return entity->getInverse(Type::IfcPresentationLayerAssignment, 2)->as(); } -IfcProductRepresentation::list::ptr IfcRepresentation::OfProductRepresentation() const { return entity->getInverse(Type::IfcProductRepresentation, 2)->as(); } -bool IfcRepresentation::is(Type::Enum v) const { return v == Type::IfcRepresentation; } -Type::Enum IfcRepresentation::type() const { return Type::IfcRepresentation; } +IfcRepresentationContext* IfcRepresentation::ContextOfItems() const { return (IfcRepresentationContext*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcRepresentation::setContextOfItems(IfcRepresentationContext* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcRepresentation::hasRepresentationIdentifier() const { return !data_->getArgument(1)->isNull(); } +std::string IfcRepresentation::RepresentationIdentifier() const { return *data_->getArgument(1); } +void IfcRepresentation::setRepresentationIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcRepresentation::hasRepresentationType() const { return !data_->getArgument(2)->isNull(); } +std::string IfcRepresentation::RepresentationType() const { return *data_->getArgument(2); } +void IfcRepresentation::setRepresentationType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcTemplatedEntityList< IfcRepresentationItem >::ptr IfcRepresentation::Items() const { IfcEntityList::ptr es = *data_->getArgument(3); return es->as(); } +void IfcRepresentation::setItems(IfcTemplatedEntityList< IfcRepresentationItem >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v->generalize()); } + +IfcRepresentationMap::list::ptr IfcRepresentation::RepresentationMap() const { return data_->getInverse(Type::IfcRepresentationMap, 1)->as(); } +IfcPresentationLayerAssignment::list::ptr IfcRepresentation::LayerAssignments() const { return data_->getInverse(Type::IfcPresentationLayerAssignment, 2)->as(); } +IfcProductRepresentation::list::ptr IfcRepresentation::OfProductRepresentation() const { return data_->getInverse(Type::IfcProductRepresentation, 2)->as(); } + +const IfcParse::entity& IfcRepresentation::declaration() const { return *IfcRepresentation_type; } Type::Enum IfcRepresentation::Class() { return Type::IfcRepresentation; } -IfcRepresentation::IfcRepresentation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRepresentation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRepresentation::IfcRepresentation(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcRepresentation::IfcRepresentation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRepresentation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRepresentation::IfcRepresentation(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRepresentationContext -bool IfcRepresentationContext::hasContextIdentifier() const { return !entity->getArgument(0)->isNull(); } -std::string IfcRepresentationContext::ContextIdentifier() const { return *entity->getArgument(0); } -void IfcRepresentationContext::setContextIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcRepresentationContext::hasContextType() const { return !entity->getArgument(1)->isNull(); } -std::string IfcRepresentationContext::ContextType() const { return *entity->getArgument(1); } -void IfcRepresentationContext::setContextType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcRepresentation::list::ptr IfcRepresentationContext::RepresentationsInContext() const { return entity->getInverse(Type::IfcRepresentation, 0)->as(); } -bool IfcRepresentationContext::is(Type::Enum v) const { return v == Type::IfcRepresentationContext; } -Type::Enum IfcRepresentationContext::type() const { return Type::IfcRepresentationContext; } +bool IfcRepresentationContext::hasContextIdentifier() const { return !data_->getArgument(0)->isNull(); } +std::string IfcRepresentationContext::ContextIdentifier() const { return *data_->getArgument(0); } +void IfcRepresentationContext::setContextIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcRepresentationContext::hasContextType() const { return !data_->getArgument(1)->isNull(); } +std::string IfcRepresentationContext::ContextType() const { return *data_->getArgument(1); } +void IfcRepresentationContext::setContextType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + +IfcRepresentation::list::ptr IfcRepresentationContext::RepresentationsInContext() const { return data_->getInverse(Type::IfcRepresentation, 0)->as(); } + +const IfcParse::entity& IfcRepresentationContext::declaration() const { return *IfcRepresentationContext_type; } Type::Enum IfcRepresentationContext::Class() { return Type::IfcRepresentationContext; } -IfcRepresentationContext::IfcRepresentationContext(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRepresentationContext)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRepresentationContext::IfcRepresentationContext(boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ContextIdentifier) { e->setArgument(0,(*v1_ContextIdentifier)); } else { e->setArgument(0); } if (v2_ContextType) { e->setArgument(1,(*v2_ContextType)); } else { e->setArgument(1); } entity = e; EntityBuffer::Add(this); } +IfcRepresentationContext::IfcRepresentationContext(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRepresentationContext)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRepresentationContext::IfcRepresentationContext(boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ContextIdentifier) { e->setArgument(0,(*v1_ContextIdentifier)); } else { e->setArgument(0); } if (v2_ContextType) { e->setArgument(1,(*v2_ContextType)); } else { e->setArgument(1); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRepresentationItem -IfcPresentationLayerAssignment::list::ptr IfcRepresentationItem::LayerAssignments() const { return entity->getInverse(Type::IfcPresentationLayerAssignment, 2)->as(); } -IfcStyledItem::list::ptr IfcRepresentationItem::StyledByItem() const { return entity->getInverse(Type::IfcStyledItem, 0)->as(); } -bool IfcRepresentationItem::is(Type::Enum v) const { return v == Type::IfcRepresentationItem; } -Type::Enum IfcRepresentationItem::type() const { return Type::IfcRepresentationItem; } + +IfcPresentationLayerAssignment::list::ptr IfcRepresentationItem::LayerAssignments() const { return data_->getInverse(Type::IfcPresentationLayerAssignment, 2)->as(); } +IfcStyledItem::list::ptr IfcRepresentationItem::StyledByItem() const { return data_->getInverse(Type::IfcStyledItem, 0)->as(); } + +const IfcParse::entity& IfcRepresentationItem::declaration() const { return *IfcRepresentationItem_type; } Type::Enum IfcRepresentationItem::Class() { return Type::IfcRepresentationItem; } -IfcRepresentationItem::IfcRepresentationItem(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRepresentationItem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRepresentationItem::IfcRepresentationItem() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcRepresentationItem::IfcRepresentationItem(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRepresentationItem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRepresentationItem::IfcRepresentationItem() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRepresentationMap -IfcAxis2Placement* IfcRepresentationMap::MappingOrigin() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcRepresentationMap::setMappingOrigin(IfcAxis2Placement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcRepresentation* IfcRepresentationMap::MappedRepresentation() const { return (IfcRepresentation*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcRepresentationMap::setMappedRepresentation(IfcRepresentation* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcMappedItem::list::ptr IfcRepresentationMap::MapUsage() const { return entity->getInverse(Type::IfcMappedItem, 0)->as(); } -bool IfcRepresentationMap::is(Type::Enum v) const { return v == Type::IfcRepresentationMap; } -Type::Enum IfcRepresentationMap::type() const { return Type::IfcRepresentationMap; } +IfcAxis2Placement* IfcRepresentationMap::MappingOrigin() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcRepresentationMap::setMappingOrigin(IfcAxis2Placement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcRepresentation* IfcRepresentationMap::MappedRepresentation() const { return (IfcRepresentation*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcRepresentationMap::setMappedRepresentation(IfcRepresentation* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + +IfcMappedItem::list::ptr IfcRepresentationMap::MapUsage() const { return data_->getInverse(Type::IfcMappedItem, 0)->as(); } + +const IfcParse::entity& IfcRepresentationMap::declaration() const { return *IfcRepresentationMap_type; } Type::Enum IfcRepresentationMap::Class() { return Type::IfcRepresentationMap; } -IfcRepresentationMap::IfcRepresentationMap(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRepresentationMap)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRepresentationMap::IfcRepresentationMap(IfcAxis2Placement* v1_MappingOrigin, IfcRepresentation* v2_MappedRepresentation) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MappingOrigin)); e->setArgument(1,(v2_MappedRepresentation)); entity = e; EntityBuffer::Add(this); } +IfcRepresentationMap::IfcRepresentationMap(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRepresentationMap)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRepresentationMap::IfcRepresentationMap(IfcAxis2Placement* v1_MappingOrigin, IfcRepresentation* v2_MappedRepresentation) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MappingOrigin)); e->setArgument(1,(v2_MappedRepresentation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcResource -IfcRelAssignsToResource::list::ptr IfcResource::ResourceOf() const { return entity->getInverse(Type::IfcRelAssignsToResource, 6)->as(); } -bool IfcResource::is(Type::Enum v) const { return v == Type::IfcResource || IfcObject::is(v); } -Type::Enum IfcResource::type() const { return Type::IfcResource; } + +IfcRelAssignsToResource::list::ptr IfcResource::ResourceOf() const { return data_->getInverse(Type::IfcRelAssignsToResource, 6)->as(); } + +const IfcParse::entity& IfcResource::declaration() const { return *IfcResource_type; } Type::Enum IfcResource::Class() { return Type::IfcResource; } -IfcResource::IfcResource(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcResource)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcResource::IfcResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcResource::IfcResource(IfcAbstractEntity* e) : IfcObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcResource)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcResource::IfcResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRevolvedAreaSolid -IfcAxis1Placement* IfcRevolvedAreaSolid::Axis() const { return (IfcAxis1Placement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcRevolvedAreaSolid::setAxis(IfcAxis1Placement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -double IfcRevolvedAreaSolid::Angle() const { return *entity->getArgument(3); } -void IfcRevolvedAreaSolid::setAngle(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcRevolvedAreaSolid::is(Type::Enum v) const { return v == Type::IfcRevolvedAreaSolid || IfcSweptAreaSolid::is(v); } -Type::Enum IfcRevolvedAreaSolid::type() const { return Type::IfcRevolvedAreaSolid; } +IfcAxis1Placement* IfcRevolvedAreaSolid::Axis() const { return (IfcAxis1Placement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcRevolvedAreaSolid::setAxis(IfcAxis1Placement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +double IfcRevolvedAreaSolid::Angle() const { return *data_->getArgument(3); } +void IfcRevolvedAreaSolid::setAngle(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcRevolvedAreaSolid::declaration() const { return *IfcRevolvedAreaSolid_type; } Type::Enum IfcRevolvedAreaSolid::Class() { return Type::IfcRevolvedAreaSolid; } -IfcRevolvedAreaSolid::IfcRevolvedAreaSolid(IfcAbstractEntity* e) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRevolvedAreaSolid)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRevolvedAreaSolid::IfcRevolvedAreaSolid(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcAxis1Placement* v3_Axis, double v4_Angle) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptArea)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_Axis)); e->setArgument(3,(v4_Angle)); entity = e; EntityBuffer::Add(this); } +IfcRevolvedAreaSolid::IfcRevolvedAreaSolid(IfcAbstractEntity* e) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRevolvedAreaSolid)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRevolvedAreaSolid::IfcRevolvedAreaSolid(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcAxis1Placement* v3_Axis, double v4_Angle) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptArea)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_Axis)); e->setArgument(3,(v4_Angle)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRibPlateProfileProperties -bool IfcRibPlateProfileProperties::hasThickness() const { return !entity->getArgument(2)->isNull(); } -double IfcRibPlateProfileProperties::Thickness() const { return *entity->getArgument(2); } -void IfcRibPlateProfileProperties::setThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcRibPlateProfileProperties::hasRibHeight() const { return !entity->getArgument(3)->isNull(); } -double IfcRibPlateProfileProperties::RibHeight() const { return *entity->getArgument(3); } -void IfcRibPlateProfileProperties::setRibHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcRibPlateProfileProperties::hasRibWidth() const { return !entity->getArgument(4)->isNull(); } -double IfcRibPlateProfileProperties::RibWidth() const { return *entity->getArgument(4); } -void IfcRibPlateProfileProperties::setRibWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcRibPlateProfileProperties::hasRibSpacing() const { return !entity->getArgument(5)->isNull(); } -double IfcRibPlateProfileProperties::RibSpacing() const { return *entity->getArgument(5); } -void IfcRibPlateProfileProperties::setRibSpacing(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum IfcRibPlateProfileProperties::Direction() const { return IfcRibPlateDirectionEnum::FromString(*entity->getArgument(6)); } -void IfcRibPlateProfileProperties::setDirection(IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcRibPlateDirectionEnum::ToString(v)); } -bool IfcRibPlateProfileProperties::is(Type::Enum v) const { return v == Type::IfcRibPlateProfileProperties || IfcProfileProperties::is(v); } -Type::Enum IfcRibPlateProfileProperties::type() const { return Type::IfcRibPlateProfileProperties; } +bool IfcRibPlateProfileProperties::hasThickness() const { return !data_->getArgument(2)->isNull(); } +double IfcRibPlateProfileProperties::Thickness() const { return *data_->getArgument(2); } +void IfcRibPlateProfileProperties::setThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcRibPlateProfileProperties::hasRibHeight() const { return !data_->getArgument(3)->isNull(); } +double IfcRibPlateProfileProperties::RibHeight() const { return *data_->getArgument(3); } +void IfcRibPlateProfileProperties::setRibHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcRibPlateProfileProperties::hasRibWidth() const { return !data_->getArgument(4)->isNull(); } +double IfcRibPlateProfileProperties::RibWidth() const { return *data_->getArgument(4); } +void IfcRibPlateProfileProperties::setRibWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcRibPlateProfileProperties::hasRibSpacing() const { return !data_->getArgument(5)->isNull(); } +double IfcRibPlateProfileProperties::RibSpacing() const { return *data_->getArgument(5); } +void IfcRibPlateProfileProperties::setRibSpacing(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum IfcRibPlateProfileProperties::Direction() const { return IfcRibPlateDirectionEnum::FromString(*data_->getArgument(6)); } +void IfcRibPlateProfileProperties::setDirection(IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcRibPlateDirectionEnum::ToString(v)); } + + +const IfcParse::entity& IfcRibPlateProfileProperties::declaration() const { return *IfcRibPlateProfileProperties_type; } Type::Enum IfcRibPlateProfileProperties::Class() { return Type::IfcRibPlateProfileProperties; } -IfcRibPlateProfileProperties::IfcRibPlateProfileProperties(IfcAbstractEntity* e) : IfcProfileProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRibPlateProfileProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRibPlateProfileProperties::IfcRibPlateProfileProperties(boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_Thickness, boost::optional< double > v4_RibHeight, boost::optional< double > v5_RibWidth, boost::optional< double > v6_RibSpacing, IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum v7_Direction) : IfcProfileProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ProfileName) { e->setArgument(0,(*v1_ProfileName)); } else { e->setArgument(0); } e->setArgument(1,(v2_ProfileDefinition)); if (v3_Thickness) { e->setArgument(2,(*v3_Thickness)); } else { e->setArgument(2); } if (v4_RibHeight) { e->setArgument(3,(*v4_RibHeight)); } else { e->setArgument(3); } if (v5_RibWidth) { e->setArgument(4,(*v5_RibWidth)); } else { e->setArgument(4); } if (v6_RibSpacing) { e->setArgument(5,(*v6_RibSpacing)); } else { e->setArgument(5); } e->setArgument(6,v7_Direction,IfcRibPlateDirectionEnum::ToString(v7_Direction)); entity = e; EntityBuffer::Add(this); } +IfcRibPlateProfileProperties::IfcRibPlateProfileProperties(IfcAbstractEntity* e) : IfcProfileProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRibPlateProfileProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRibPlateProfileProperties::IfcRibPlateProfileProperties(boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_Thickness, boost::optional< double > v4_RibHeight, boost::optional< double > v5_RibWidth, boost::optional< double > v6_RibSpacing, IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum v7_Direction) : IfcProfileProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ProfileName) { e->setArgument(0,(*v1_ProfileName)); } else { e->setArgument(0); } e->setArgument(1,(v2_ProfileDefinition)); if (v3_Thickness) { e->setArgument(2,(*v3_Thickness)); } else { e->setArgument(2); } if (v4_RibHeight) { e->setArgument(3,(*v4_RibHeight)); } else { e->setArgument(3); } if (v5_RibWidth) { e->setArgument(4,(*v5_RibWidth)); } else { e->setArgument(4); } if (v6_RibSpacing) { e->setArgument(5,(*v6_RibSpacing)); } else { e->setArgument(5); } e->setArgument(6,v7_Direction,IfcRibPlateDirectionEnum::ToString(v7_Direction)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRightCircularCone -double IfcRightCircularCone::Height() const { return *entity->getArgument(1); } -void IfcRightCircularCone::setHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcRightCircularCone::BottomRadius() const { return *entity->getArgument(2); } -void IfcRightCircularCone::setBottomRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcRightCircularCone::is(Type::Enum v) const { return v == Type::IfcRightCircularCone || IfcCsgPrimitive3D::is(v); } -Type::Enum IfcRightCircularCone::type() const { return Type::IfcRightCircularCone; } +double IfcRightCircularCone::Height() const { return *data_->getArgument(1); } +void IfcRightCircularCone::setHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcRightCircularCone::BottomRadius() const { return *data_->getArgument(2); } +void IfcRightCircularCone::setBottomRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcRightCircularCone::declaration() const { return *IfcRightCircularCone_type; } Type::Enum IfcRightCircularCone::Class() { return Type::IfcRightCircularCone; } -IfcRightCircularCone::IfcRightCircularCone(IfcAbstractEntity* e) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRightCircularCone)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRightCircularCone::IfcRightCircularCone(IfcAxis2Placement3D* v1_Position, double v2_Height, double v3_BottomRadius) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_Height)); e->setArgument(2,(v3_BottomRadius)); entity = e; EntityBuffer::Add(this); } +IfcRightCircularCone::IfcRightCircularCone(IfcAbstractEntity* e) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRightCircularCone)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRightCircularCone::IfcRightCircularCone(IfcAxis2Placement3D* v1_Position, double v2_Height, double v3_BottomRadius) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_Height)); e->setArgument(2,(v3_BottomRadius)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRightCircularCylinder -double IfcRightCircularCylinder::Height() const { return *entity->getArgument(1); } -void IfcRightCircularCylinder::setHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -double IfcRightCircularCylinder::Radius() const { return *entity->getArgument(2); } -void IfcRightCircularCylinder::setRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcRightCircularCylinder::is(Type::Enum v) const { return v == Type::IfcRightCircularCylinder || IfcCsgPrimitive3D::is(v); } -Type::Enum IfcRightCircularCylinder::type() const { return Type::IfcRightCircularCylinder; } +double IfcRightCircularCylinder::Height() const { return *data_->getArgument(1); } +void IfcRightCircularCylinder::setHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +double IfcRightCircularCylinder::Radius() const { return *data_->getArgument(2); } +void IfcRightCircularCylinder::setRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcRightCircularCylinder::declaration() const { return *IfcRightCircularCylinder_type; } Type::Enum IfcRightCircularCylinder::Class() { return Type::IfcRightCircularCylinder; } -IfcRightCircularCylinder::IfcRightCircularCylinder(IfcAbstractEntity* e) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRightCircularCylinder)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRightCircularCylinder::IfcRightCircularCylinder(IfcAxis2Placement3D* v1_Position, double v2_Height, double v3_Radius) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_Height)); e->setArgument(2,(v3_Radius)); entity = e; EntityBuffer::Add(this); } +IfcRightCircularCylinder::IfcRightCircularCylinder(IfcAbstractEntity* e) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRightCircularCylinder)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRightCircularCylinder::IfcRightCircularCylinder(IfcAxis2Placement3D* v1_Position, double v2_Height, double v3_Radius) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_Height)); e->setArgument(2,(v3_Radius)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRoof -IfcRoofTypeEnum::IfcRoofTypeEnum IfcRoof::ShapeType() const { return IfcRoofTypeEnum::FromString(*entity->getArgument(8)); } -void IfcRoof::setShapeType(IfcRoofTypeEnum::IfcRoofTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcRoofTypeEnum::ToString(v)); } -bool IfcRoof::is(Type::Enum v) const { return v == Type::IfcRoof || IfcBuildingElement::is(v); } -Type::Enum IfcRoof::type() const { return Type::IfcRoof; } +IfcRoofTypeEnum::IfcRoofTypeEnum IfcRoof::ShapeType() const { return IfcRoofTypeEnum::FromString(*data_->getArgument(8)); } +void IfcRoof::setShapeType(IfcRoofTypeEnum::IfcRoofTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcRoofTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcRoof::declaration() const { return *IfcRoof_type; } Type::Enum IfcRoof::Class() { return Type::IfcRoof; } -IfcRoof::IfcRoof(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRoof)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRoof::IfcRoof(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcRoofTypeEnum::IfcRoofTypeEnum v9_ShapeType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_ShapeType,IfcRoofTypeEnum::ToString(v9_ShapeType)); entity = e; EntityBuffer::Add(this); } +IfcRoof::IfcRoof(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRoof)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRoof::IfcRoof(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcRoofTypeEnum::IfcRoofTypeEnum v9_ShapeType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_ShapeType,IfcRoofTypeEnum::ToString(v9_ShapeType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRoot -std::string IfcRoot::GlobalId() const { return *entity->getArgument(0); } -void IfcRoot::setGlobalId(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcOwnerHistory* IfcRoot::OwnerHistory() const { return (IfcOwnerHistory*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcRoot::setOwnerHistory(IfcOwnerHistory* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcRoot::hasName() const { return !entity->getArgument(2)->isNull(); } -std::string IfcRoot::Name() const { return *entity->getArgument(2); } -void IfcRoot::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcRoot::hasDescription() const { return !entity->getArgument(3)->isNull(); } -std::string IfcRoot::Description() const { return *entity->getArgument(3); } -void IfcRoot::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcRoot::is(Type::Enum v) const { return v == Type::IfcRoot; } -Type::Enum IfcRoot::type() const { return Type::IfcRoot; } +std::string IfcRoot::GlobalId() const { return *data_->getArgument(0); } +void IfcRoot::setGlobalId(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcOwnerHistory* IfcRoot::OwnerHistory() const { return (IfcOwnerHistory*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcRoot::setOwnerHistory(IfcOwnerHistory* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcRoot::hasName() const { return !data_->getArgument(2)->isNull(); } +std::string IfcRoot::Name() const { return *data_->getArgument(2); } +void IfcRoot::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcRoot::hasDescription() const { return !data_->getArgument(3)->isNull(); } +std::string IfcRoot::Description() const { return *data_->getArgument(3); } +void IfcRoot::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcRoot::declaration() const { return *IfcRoot_type; } Type::Enum IfcRoot::Class() { return Type::IfcRoot; } -IfcRoot::IfcRoot(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRoot)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRoot::IfcRoot(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcRoot::IfcRoot(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRoot)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRoot::IfcRoot(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRoundedEdgeFeature -bool IfcRoundedEdgeFeature::hasRadius() const { return !entity->getArgument(9)->isNull(); } -double IfcRoundedEdgeFeature::Radius() const { return *entity->getArgument(9); } -void IfcRoundedEdgeFeature::setRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcRoundedEdgeFeature::is(Type::Enum v) const { return v == Type::IfcRoundedEdgeFeature || IfcEdgeFeature::is(v); } -Type::Enum IfcRoundedEdgeFeature::type() const { return Type::IfcRoundedEdgeFeature; } +bool IfcRoundedEdgeFeature::hasRadius() const { return !data_->getArgument(9)->isNull(); } +double IfcRoundedEdgeFeature::Radius() const { return *data_->getArgument(9); } +void IfcRoundedEdgeFeature::setRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcRoundedEdgeFeature::declaration() const { return *IfcRoundedEdgeFeature_type; } Type::Enum IfcRoundedEdgeFeature::Class() { return Type::IfcRoundedEdgeFeature; } -IfcRoundedEdgeFeature::IfcRoundedEdgeFeature(IfcAbstractEntity* e) : IfcEdgeFeature((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRoundedEdgeFeature)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRoundedEdgeFeature::IfcRoundedEdgeFeature(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength, boost::optional< double > v10_Radius) : IfcEdgeFeature((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_FeatureLength) { e->setArgument(8,(*v9_FeatureLength)); } else { e->setArgument(8); } if (v10_Radius) { e->setArgument(9,(*v10_Radius)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcRoundedEdgeFeature::IfcRoundedEdgeFeature(IfcAbstractEntity* e) : IfcEdgeFeature((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRoundedEdgeFeature)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRoundedEdgeFeature::IfcRoundedEdgeFeature(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength, boost::optional< double > v10_Radius) : IfcEdgeFeature((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_FeatureLength) { e->setArgument(8,(*v9_FeatureLength)); } else { e->setArgument(8); } if (v10_Radius) { e->setArgument(9,(*v10_Radius)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRoundedRectangleProfileDef -double IfcRoundedRectangleProfileDef::RoundingRadius() const { return *entity->getArgument(5); } -void IfcRoundedRectangleProfileDef::setRoundingRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRoundedRectangleProfileDef::is(Type::Enum v) const { return v == Type::IfcRoundedRectangleProfileDef || IfcRectangleProfileDef::is(v); } -Type::Enum IfcRoundedRectangleProfileDef::type() const { return Type::IfcRoundedRectangleProfileDef; } +double IfcRoundedRectangleProfileDef::RoundingRadius() const { return *data_->getArgument(5); } +void IfcRoundedRectangleProfileDef::setRoundingRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRoundedRectangleProfileDef::declaration() const { return *IfcRoundedRectangleProfileDef_type; } Type::Enum IfcRoundedRectangleProfileDef::Class() { return Type::IfcRoundedRectangleProfileDef; } -IfcRoundedRectangleProfileDef::IfcRoundedRectangleProfileDef(IfcAbstractEntity* e) : IfcRectangleProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRoundedRectangleProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRoundedRectangleProfileDef::IfcRoundedRectangleProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim, double v6_RoundingRadius) : IfcRectangleProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_XDim)); e->setArgument(4,(v5_YDim)); e->setArgument(5,(v6_RoundingRadius)); entity = e; EntityBuffer::Add(this); } +IfcRoundedRectangleProfileDef::IfcRoundedRectangleProfileDef(IfcAbstractEntity* e) : IfcRectangleProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRoundedRectangleProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRoundedRectangleProfileDef::IfcRoundedRectangleProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim, double v6_RoundingRadius) : IfcRectangleProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_XDim)); e->setArgument(4,(v5_YDim)); e->setArgument(5,(v6_RoundingRadius)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSIUnit -bool IfcSIUnit::hasPrefix() const { return !entity->getArgument(2)->isNull(); } -IfcSIPrefix::IfcSIPrefix IfcSIUnit::Prefix() const { return IfcSIPrefix::FromString(*entity->getArgument(2)); } -void IfcSIUnit::setPrefix(IfcSIPrefix::IfcSIPrefix v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v,IfcSIPrefix::ToString(v)); } -IfcSIUnitName::IfcSIUnitName IfcSIUnit::Name() const { return IfcSIUnitName::FromString(*entity->getArgument(3)); } -void IfcSIUnit::setName(IfcSIUnitName::IfcSIUnitName v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v,IfcSIUnitName::ToString(v)); } -bool IfcSIUnit::is(Type::Enum v) const { return v == Type::IfcSIUnit || IfcNamedUnit::is(v); } -Type::Enum IfcSIUnit::type() const { return Type::IfcSIUnit; } +bool IfcSIUnit::hasPrefix() const { return !data_->getArgument(2)->isNull(); } +IfcSIPrefix::IfcSIPrefix IfcSIUnit::Prefix() const { return IfcSIPrefix::FromString(*data_->getArgument(2)); } +void IfcSIUnit::setPrefix(IfcSIPrefix::IfcSIPrefix v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v,IfcSIPrefix::ToString(v)); } +IfcSIUnitName::IfcSIUnitName IfcSIUnit::Name() const { return IfcSIUnitName::FromString(*data_->getArgument(3)); } +void IfcSIUnit::setName(IfcSIUnitName::IfcSIUnitName v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v,IfcSIUnitName::ToString(v)); } + + +const IfcParse::entity& IfcSIUnit::declaration() const { return *IfcSIUnit_type; } Type::Enum IfcSIUnit::Class() { return Type::IfcSIUnit; } -IfcSIUnit::IfcSIUnit(IfcAbstractEntity* e) : IfcNamedUnit((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSIUnit)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSIUnit::IfcSIUnit(IfcUnitEnum::IfcUnitEnum v2_UnitType, boost::optional< IfcSIPrefix::IfcSIPrefix > v3_Prefix, IfcSIUnitName::IfcSIUnitName v4_Name) : IfcNamedUnit((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgumentDerived(0); e->setArgument(1,v2_UnitType,IfcUnitEnum::ToString(v2_UnitType)); if (v3_Prefix) { e->setArgument(2,*v3_Prefix,IfcSIPrefix::ToString(*v3_Prefix)); } else { e->setArgument(2); } e->setArgument(3,v4_Name,IfcSIUnitName::ToString(v4_Name)); entity = e; EntityBuffer::Add(this); } +IfcSIUnit::IfcSIUnit(IfcAbstractEntity* e) : IfcNamedUnit((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSIUnit)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSIUnit::IfcSIUnit(IfcUnitEnum::IfcUnitEnum v2_UnitType, boost::optional< IfcSIPrefix::IfcSIPrefix > v3_Prefix, IfcSIUnitName::IfcSIUnitName v4_Name) : IfcNamedUnit((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgumentDerived(0); e->setArgument(1,v2_UnitType,IfcUnitEnum::ToString(v2_UnitType)); if (v3_Prefix) { e->setArgument(2,*v3_Prefix,IfcSIPrefix::ToString(*v3_Prefix)); } else { e->setArgument(2); } e->setArgument(3,v4_Name,IfcSIUnitName::ToString(v4_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSanitaryTerminalType -IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum IfcSanitaryTerminalType::PredefinedType() const { return IfcSanitaryTerminalTypeEnum::FromString(*entity->getArgument(9)); } -void IfcSanitaryTerminalType::setPredefinedType(IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcSanitaryTerminalTypeEnum::ToString(v)); } -bool IfcSanitaryTerminalType::is(Type::Enum v) const { return v == Type::IfcSanitaryTerminalType || IfcFlowTerminalType::is(v); } -Type::Enum IfcSanitaryTerminalType::type() const { return Type::IfcSanitaryTerminalType; } +IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum IfcSanitaryTerminalType::PredefinedType() const { return IfcSanitaryTerminalTypeEnum::FromString(*data_->getArgument(9)); } +void IfcSanitaryTerminalType::setPredefinedType(IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcSanitaryTerminalTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSanitaryTerminalType::declaration() const { return *IfcSanitaryTerminalType_type; } Type::Enum IfcSanitaryTerminalType::Class() { return Type::IfcSanitaryTerminalType; } -IfcSanitaryTerminalType::IfcSanitaryTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSanitaryTerminalType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSanitaryTerminalType::IfcSanitaryTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSanitaryTerminalTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcSanitaryTerminalType::IfcSanitaryTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSanitaryTerminalType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSanitaryTerminalType::IfcSanitaryTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSanitaryTerminalTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcScheduleTimeControl -bool IfcScheduleTimeControl::hasActualStart() const { return !entity->getArgument(5)->isNull(); } -IfcDateTimeSelect* IfcScheduleTimeControl::ActualStart() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcScheduleTimeControl::setActualStart(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcScheduleTimeControl::hasEarlyStart() const { return !entity->getArgument(6)->isNull(); } -IfcDateTimeSelect* IfcScheduleTimeControl::EarlyStart() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcScheduleTimeControl::setEarlyStart(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcScheduleTimeControl::hasLateStart() const { return !entity->getArgument(7)->isNull(); } -IfcDateTimeSelect* IfcScheduleTimeControl::LateStart() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcScheduleTimeControl::setLateStart(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcScheduleTimeControl::hasScheduleStart() const { return !entity->getArgument(8)->isNull(); } -IfcDateTimeSelect* IfcScheduleTimeControl::ScheduleStart() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcScheduleTimeControl::setScheduleStart(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcScheduleTimeControl::hasActualFinish() const { return !entity->getArgument(9)->isNull(); } -IfcDateTimeSelect* IfcScheduleTimeControl::ActualFinish() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcScheduleTimeControl::setActualFinish(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcScheduleTimeControl::hasEarlyFinish() const { return !entity->getArgument(10)->isNull(); } -IfcDateTimeSelect* IfcScheduleTimeControl::EarlyFinish() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcScheduleTimeControl::setEarlyFinish(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcScheduleTimeControl::hasLateFinish() const { return !entity->getArgument(11)->isNull(); } -IfcDateTimeSelect* IfcScheduleTimeControl::LateFinish() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(11))); } -void IfcScheduleTimeControl::setLateFinish(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcScheduleTimeControl::hasScheduleFinish() const { return !entity->getArgument(12)->isNull(); } -IfcDateTimeSelect* IfcScheduleTimeControl::ScheduleFinish() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(12))); } -void IfcScheduleTimeControl::setScheduleFinish(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcScheduleTimeControl::hasScheduleDuration() const { return !entity->getArgument(13)->isNull(); } -double IfcScheduleTimeControl::ScheduleDuration() const { return *entity->getArgument(13); } -void IfcScheduleTimeControl::setScheduleDuration(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcScheduleTimeControl::hasActualDuration() const { return !entity->getArgument(14)->isNull(); } -double IfcScheduleTimeControl::ActualDuration() const { return *entity->getArgument(14); } -void IfcScheduleTimeControl::setActualDuration(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcScheduleTimeControl::hasRemainingTime() const { return !entity->getArgument(15)->isNull(); } -double IfcScheduleTimeControl::RemainingTime() const { return *entity->getArgument(15); } -void IfcScheduleTimeControl::setRemainingTime(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v); } -bool IfcScheduleTimeControl::hasFreeFloat() const { return !entity->getArgument(16)->isNull(); } -double IfcScheduleTimeControl::FreeFloat() const { return *entity->getArgument(16); } -void IfcScheduleTimeControl::setFreeFloat(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(16,v); } -bool IfcScheduleTimeControl::hasTotalFloat() const { return !entity->getArgument(17)->isNull(); } -double IfcScheduleTimeControl::TotalFloat() const { return *entity->getArgument(17); } -void IfcScheduleTimeControl::setTotalFloat(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(17,v); } -bool IfcScheduleTimeControl::hasIsCritical() const { return !entity->getArgument(18)->isNull(); } -bool IfcScheduleTimeControl::IsCritical() const { return *entity->getArgument(18); } -void IfcScheduleTimeControl::setIsCritical(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(18,v); } -bool IfcScheduleTimeControl::hasStatusTime() const { return !entity->getArgument(19)->isNull(); } -IfcDateTimeSelect* IfcScheduleTimeControl::StatusTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(19))); } -void IfcScheduleTimeControl::setStatusTime(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(19,v); } -bool IfcScheduleTimeControl::hasStartFloat() const { return !entity->getArgument(20)->isNull(); } -double IfcScheduleTimeControl::StartFloat() const { return *entity->getArgument(20); } -void IfcScheduleTimeControl::setStartFloat(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(20,v); } -bool IfcScheduleTimeControl::hasFinishFloat() const { return !entity->getArgument(21)->isNull(); } -double IfcScheduleTimeControl::FinishFloat() const { return *entity->getArgument(21); } -void IfcScheduleTimeControl::setFinishFloat(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(21,v); } -bool IfcScheduleTimeControl::hasCompletion() const { return !entity->getArgument(22)->isNull(); } -double IfcScheduleTimeControl::Completion() const { return *entity->getArgument(22); } -void IfcScheduleTimeControl::setCompletion(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(22,v); } -IfcRelAssignsTasks::list::ptr IfcScheduleTimeControl::ScheduleTimeControlAssigned() const { return entity->getInverse(Type::IfcRelAssignsTasks, 7)->as(); } -bool IfcScheduleTimeControl::is(Type::Enum v) const { return v == Type::IfcScheduleTimeControl || IfcControl::is(v); } -Type::Enum IfcScheduleTimeControl::type() const { return Type::IfcScheduleTimeControl; } +bool IfcScheduleTimeControl::hasActualStart() const { return !data_->getArgument(5)->isNull(); } +IfcDateTimeSelect* IfcScheduleTimeControl::ActualStart() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcScheduleTimeControl::setActualStart(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcScheduleTimeControl::hasEarlyStart() const { return !data_->getArgument(6)->isNull(); } +IfcDateTimeSelect* IfcScheduleTimeControl::EarlyStart() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcScheduleTimeControl::setEarlyStart(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcScheduleTimeControl::hasLateStart() const { return !data_->getArgument(7)->isNull(); } +IfcDateTimeSelect* IfcScheduleTimeControl::LateStart() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcScheduleTimeControl::setLateStart(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcScheduleTimeControl::hasScheduleStart() const { return !data_->getArgument(8)->isNull(); } +IfcDateTimeSelect* IfcScheduleTimeControl::ScheduleStart() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcScheduleTimeControl::setScheduleStart(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcScheduleTimeControl::hasActualFinish() const { return !data_->getArgument(9)->isNull(); } +IfcDateTimeSelect* IfcScheduleTimeControl::ActualFinish() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcScheduleTimeControl::setActualFinish(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcScheduleTimeControl::hasEarlyFinish() const { return !data_->getArgument(10)->isNull(); } +IfcDateTimeSelect* IfcScheduleTimeControl::EarlyFinish() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcScheduleTimeControl::setEarlyFinish(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcScheduleTimeControl::hasLateFinish() const { return !data_->getArgument(11)->isNull(); } +IfcDateTimeSelect* IfcScheduleTimeControl::LateFinish() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(11))); } +void IfcScheduleTimeControl::setLateFinish(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcScheduleTimeControl::hasScheduleFinish() const { return !data_->getArgument(12)->isNull(); } +IfcDateTimeSelect* IfcScheduleTimeControl::ScheduleFinish() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(12))); } +void IfcScheduleTimeControl::setScheduleFinish(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcScheduleTimeControl::hasScheduleDuration() const { return !data_->getArgument(13)->isNull(); } +double IfcScheduleTimeControl::ScheduleDuration() const { return *data_->getArgument(13); } +void IfcScheduleTimeControl::setScheduleDuration(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcScheduleTimeControl::hasActualDuration() const { return !data_->getArgument(14)->isNull(); } +double IfcScheduleTimeControl::ActualDuration() const { return *data_->getArgument(14); } +void IfcScheduleTimeControl::setActualDuration(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } +bool IfcScheduleTimeControl::hasRemainingTime() const { return !data_->getArgument(15)->isNull(); } +double IfcScheduleTimeControl::RemainingTime() const { return *data_->getArgument(15); } +void IfcScheduleTimeControl::setRemainingTime(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v); } +bool IfcScheduleTimeControl::hasFreeFloat() const { return !data_->getArgument(16)->isNull(); } +double IfcScheduleTimeControl::FreeFloat() const { return *data_->getArgument(16); } +void IfcScheduleTimeControl::setFreeFloat(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(16,v); } +bool IfcScheduleTimeControl::hasTotalFloat() const { return !data_->getArgument(17)->isNull(); } +double IfcScheduleTimeControl::TotalFloat() const { return *data_->getArgument(17); } +void IfcScheduleTimeControl::setTotalFloat(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(17,v); } +bool IfcScheduleTimeControl::hasIsCritical() const { return !data_->getArgument(18)->isNull(); } +bool IfcScheduleTimeControl::IsCritical() const { return *data_->getArgument(18); } +void IfcScheduleTimeControl::setIsCritical(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(18,v); } +bool IfcScheduleTimeControl::hasStatusTime() const { return !data_->getArgument(19)->isNull(); } +IfcDateTimeSelect* IfcScheduleTimeControl::StatusTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(19))); } +void IfcScheduleTimeControl::setStatusTime(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(19,v); } +bool IfcScheduleTimeControl::hasStartFloat() const { return !data_->getArgument(20)->isNull(); } +double IfcScheduleTimeControl::StartFloat() const { return *data_->getArgument(20); } +void IfcScheduleTimeControl::setStartFloat(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(20,v); } +bool IfcScheduleTimeControl::hasFinishFloat() const { return !data_->getArgument(21)->isNull(); } +double IfcScheduleTimeControl::FinishFloat() const { return *data_->getArgument(21); } +void IfcScheduleTimeControl::setFinishFloat(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(21,v); } +bool IfcScheduleTimeControl::hasCompletion() const { return !data_->getArgument(22)->isNull(); } +double IfcScheduleTimeControl::Completion() const { return *data_->getArgument(22); } +void IfcScheduleTimeControl::setCompletion(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(22,v); } + +IfcRelAssignsTasks::list::ptr IfcScheduleTimeControl::ScheduleTimeControlAssigned() const { return data_->getInverse(Type::IfcRelAssignsTasks, 7)->as(); } + +const IfcParse::entity& IfcScheduleTimeControl::declaration() const { return *IfcScheduleTimeControl_type; } Type::Enum IfcScheduleTimeControl::Class() { return Type::IfcScheduleTimeControl; } -IfcScheduleTimeControl::IfcScheduleTimeControl(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcScheduleTimeControl)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcScheduleTimeControl::IfcScheduleTimeControl(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcDateTimeSelect* v6_ActualStart, IfcDateTimeSelect* v7_EarlyStart, IfcDateTimeSelect* v8_LateStart, IfcDateTimeSelect* v9_ScheduleStart, IfcDateTimeSelect* v10_ActualFinish, IfcDateTimeSelect* v11_EarlyFinish, IfcDateTimeSelect* v12_LateFinish, IfcDateTimeSelect* v13_ScheduleFinish, boost::optional< double > v14_ScheduleDuration, boost::optional< double > v15_ActualDuration, boost::optional< double > v16_RemainingTime, boost::optional< double > v17_FreeFloat, boost::optional< double > v18_TotalFloat, boost::optional< bool > v19_IsCritical, IfcDateTimeSelect* v20_StatusTime, boost::optional< double > v21_StartFloat, boost::optional< double > v22_FinishFloat, boost::optional< double > v23_Completion) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ActualStart)); e->setArgument(6,(v7_EarlyStart)); e->setArgument(7,(v8_LateStart)); e->setArgument(8,(v9_ScheduleStart)); e->setArgument(9,(v10_ActualFinish)); e->setArgument(10,(v11_EarlyFinish)); e->setArgument(11,(v12_LateFinish)); e->setArgument(12,(v13_ScheduleFinish)); if (v14_ScheduleDuration) { e->setArgument(13,(*v14_ScheduleDuration)); } else { e->setArgument(13); } if (v15_ActualDuration) { e->setArgument(14,(*v15_ActualDuration)); } else { e->setArgument(14); } if (v16_RemainingTime) { e->setArgument(15,(*v16_RemainingTime)); } else { e->setArgument(15); } if (v17_FreeFloat) { e->setArgument(16,(*v17_FreeFloat)); } else { e->setArgument(16); } if (v18_TotalFloat) { e->setArgument(17,(*v18_TotalFloat)); } else { e->setArgument(17); } if (v19_IsCritical) { e->setArgument(18,(*v19_IsCritical)); } else { e->setArgument(18); } e->setArgument(19,(v20_StatusTime)); if (v21_StartFloat) { e->setArgument(20,(*v21_StartFloat)); } else { e->setArgument(20); } if (v22_FinishFloat) { e->setArgument(21,(*v22_FinishFloat)); } else { e->setArgument(21); } if (v23_Completion) { e->setArgument(22,(*v23_Completion)); } else { e->setArgument(22); } entity = e; EntityBuffer::Add(this); } +IfcScheduleTimeControl::IfcScheduleTimeControl(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcScheduleTimeControl)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcScheduleTimeControl::IfcScheduleTimeControl(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcDateTimeSelect* v6_ActualStart, IfcDateTimeSelect* v7_EarlyStart, IfcDateTimeSelect* v8_LateStart, IfcDateTimeSelect* v9_ScheduleStart, IfcDateTimeSelect* v10_ActualFinish, IfcDateTimeSelect* v11_EarlyFinish, IfcDateTimeSelect* v12_LateFinish, IfcDateTimeSelect* v13_ScheduleFinish, boost::optional< double > v14_ScheduleDuration, boost::optional< double > v15_ActualDuration, boost::optional< double > v16_RemainingTime, boost::optional< double > v17_FreeFloat, boost::optional< double > v18_TotalFloat, boost::optional< bool > v19_IsCritical, IfcDateTimeSelect* v20_StatusTime, boost::optional< double > v21_StartFloat, boost::optional< double > v22_FinishFloat, boost::optional< double > v23_Completion) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ActualStart)); e->setArgument(6,(v7_EarlyStart)); e->setArgument(7,(v8_LateStart)); e->setArgument(8,(v9_ScheduleStart)); e->setArgument(9,(v10_ActualFinish)); e->setArgument(10,(v11_EarlyFinish)); e->setArgument(11,(v12_LateFinish)); e->setArgument(12,(v13_ScheduleFinish)); if (v14_ScheduleDuration) { e->setArgument(13,(*v14_ScheduleDuration)); } else { e->setArgument(13); } if (v15_ActualDuration) { e->setArgument(14,(*v15_ActualDuration)); } else { e->setArgument(14); } if (v16_RemainingTime) { e->setArgument(15,(*v16_RemainingTime)); } else { e->setArgument(15); } if (v17_FreeFloat) { e->setArgument(16,(*v17_FreeFloat)); } else { e->setArgument(16); } if (v18_TotalFloat) { e->setArgument(17,(*v18_TotalFloat)); } else { e->setArgument(17); } if (v19_IsCritical) { e->setArgument(18,(*v19_IsCritical)); } else { e->setArgument(18); } e->setArgument(19,(v20_StatusTime)); if (v21_StartFloat) { e->setArgument(20,(*v21_StartFloat)); } else { e->setArgument(20); } if (v22_FinishFloat) { e->setArgument(21,(*v22_FinishFloat)); } else { e->setArgument(21); } if (v23_Completion) { e->setArgument(22,(*v23_Completion)); } else { e->setArgument(22); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSectionProperties -IfcSectionTypeEnum::IfcSectionTypeEnum IfcSectionProperties::SectionType() const { return IfcSectionTypeEnum::FromString(*entity->getArgument(0)); } -void IfcSectionProperties::setSectionType(IfcSectionTypeEnum::IfcSectionTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v,IfcSectionTypeEnum::ToString(v)); } -IfcProfileDef* IfcSectionProperties::StartProfile() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcSectionProperties::setStartProfile(IfcProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcSectionProperties::hasEndProfile() const { return !entity->getArgument(2)->isNull(); } -IfcProfileDef* IfcSectionProperties::EndProfile() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcSectionProperties::setEndProfile(IfcProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcSectionProperties::is(Type::Enum v) const { return v == Type::IfcSectionProperties; } -Type::Enum IfcSectionProperties::type() const { return Type::IfcSectionProperties; } +IfcSectionTypeEnum::IfcSectionTypeEnum IfcSectionProperties::SectionType() const { return IfcSectionTypeEnum::FromString(*data_->getArgument(0)); } +void IfcSectionProperties::setSectionType(IfcSectionTypeEnum::IfcSectionTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v,IfcSectionTypeEnum::ToString(v)); } +IfcProfileDef* IfcSectionProperties::StartProfile() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcSectionProperties::setStartProfile(IfcProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcSectionProperties::hasEndProfile() const { return !data_->getArgument(2)->isNull(); } +IfcProfileDef* IfcSectionProperties::EndProfile() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcSectionProperties::setEndProfile(IfcProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcSectionProperties::declaration() const { return *IfcSectionProperties_type; } Type::Enum IfcSectionProperties::Class() { return Type::IfcSectionProperties; } -IfcSectionProperties::IfcSectionProperties(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSectionProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSectionProperties::IfcSectionProperties(IfcSectionTypeEnum::IfcSectionTypeEnum v1_SectionType, IfcProfileDef* v2_StartProfile, IfcProfileDef* v3_EndProfile) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_SectionType,IfcSectionTypeEnum::ToString(v1_SectionType)); e->setArgument(1,(v2_StartProfile)); e->setArgument(2,(v3_EndProfile)); entity = e; EntityBuffer::Add(this); } +IfcSectionProperties::IfcSectionProperties(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSectionProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSectionProperties::IfcSectionProperties(IfcSectionTypeEnum::IfcSectionTypeEnum v1_SectionType, IfcProfileDef* v2_StartProfile, IfcProfileDef* v3_EndProfile) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_SectionType,IfcSectionTypeEnum::ToString(v1_SectionType)); e->setArgument(1,(v2_StartProfile)); e->setArgument(2,(v3_EndProfile)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSectionReinforcementProperties -double IfcSectionReinforcementProperties::LongitudinalStartPosition() const { return *entity->getArgument(0); } -void IfcSectionReinforcementProperties::setLongitudinalStartPosition(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcSectionReinforcementProperties::LongitudinalEndPosition() const { return *entity->getArgument(1); } -void IfcSectionReinforcementProperties::setLongitudinalEndPosition(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcSectionReinforcementProperties::hasTransversePosition() const { return !entity->getArgument(2)->isNull(); } -double IfcSectionReinforcementProperties::TransversePosition() const { return *entity->getArgument(2); } -void IfcSectionReinforcementProperties::setTransversePosition(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum IfcSectionReinforcementProperties::ReinforcementRole() const { return IfcReinforcingBarRoleEnum::FromString(*entity->getArgument(3)); } -void IfcSectionReinforcementProperties::setReinforcementRole(IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v,IfcReinforcingBarRoleEnum::ToString(v)); } -IfcSectionProperties* IfcSectionReinforcementProperties::SectionDefinition() const { return (IfcSectionProperties*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcSectionReinforcementProperties::setSectionDefinition(IfcSectionProperties* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcTemplatedEntityList< IfcReinforcementBarProperties >::ptr IfcSectionReinforcementProperties::CrossSectionReinforcementDefinitions() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcSectionReinforcementProperties::setCrossSectionReinforcementDefinitions(IfcTemplatedEntityList< IfcReinforcementBarProperties >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v->generalize()); } -bool IfcSectionReinforcementProperties::is(Type::Enum v) const { return v == Type::IfcSectionReinforcementProperties; } -Type::Enum IfcSectionReinforcementProperties::type() const { return Type::IfcSectionReinforcementProperties; } +double IfcSectionReinforcementProperties::LongitudinalStartPosition() const { return *data_->getArgument(0); } +void IfcSectionReinforcementProperties::setLongitudinalStartPosition(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcSectionReinforcementProperties::LongitudinalEndPosition() const { return *data_->getArgument(1); } +void IfcSectionReinforcementProperties::setLongitudinalEndPosition(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcSectionReinforcementProperties::hasTransversePosition() const { return !data_->getArgument(2)->isNull(); } +double IfcSectionReinforcementProperties::TransversePosition() const { return *data_->getArgument(2); } +void IfcSectionReinforcementProperties::setTransversePosition(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum IfcSectionReinforcementProperties::ReinforcementRole() const { return IfcReinforcingBarRoleEnum::FromString(*data_->getArgument(3)); } +void IfcSectionReinforcementProperties::setReinforcementRole(IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v,IfcReinforcingBarRoleEnum::ToString(v)); } +IfcSectionProperties* IfcSectionReinforcementProperties::SectionDefinition() const { return (IfcSectionProperties*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcSectionReinforcementProperties::setSectionDefinition(IfcSectionProperties* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcTemplatedEntityList< IfcReinforcementBarProperties >::ptr IfcSectionReinforcementProperties::CrossSectionReinforcementDefinitions() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcSectionReinforcementProperties::setCrossSectionReinforcementDefinitions(IfcTemplatedEntityList< IfcReinforcementBarProperties >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v->generalize()); } + + +const IfcParse::entity& IfcSectionReinforcementProperties::declaration() const { return *IfcSectionReinforcementProperties_type; } Type::Enum IfcSectionReinforcementProperties::Class() { return Type::IfcSectionReinforcementProperties; } -IfcSectionReinforcementProperties::IfcSectionReinforcementProperties(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSectionReinforcementProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSectionReinforcementProperties::IfcSectionReinforcementProperties(double v1_LongitudinalStartPosition, double v2_LongitudinalEndPosition, boost::optional< double > v3_TransversePosition, IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum v4_ReinforcementRole, IfcSectionProperties* v5_SectionDefinition, IfcTemplatedEntityList< IfcReinforcementBarProperties >::ptr v6_CrossSectionReinforcementDefinitions) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_LongitudinalStartPosition)); e->setArgument(1,(v2_LongitudinalEndPosition)); if (v3_TransversePosition) { e->setArgument(2,(*v3_TransversePosition)); } else { e->setArgument(2); } e->setArgument(3,v4_ReinforcementRole,IfcReinforcingBarRoleEnum::ToString(v4_ReinforcementRole)); e->setArgument(4,(v5_SectionDefinition)); e->setArgument(5,(v6_CrossSectionReinforcementDefinitions)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcSectionReinforcementProperties::IfcSectionReinforcementProperties(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSectionReinforcementProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSectionReinforcementProperties::IfcSectionReinforcementProperties(double v1_LongitudinalStartPosition, double v2_LongitudinalEndPosition, boost::optional< double > v3_TransversePosition, IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum v4_ReinforcementRole, IfcSectionProperties* v5_SectionDefinition, IfcTemplatedEntityList< IfcReinforcementBarProperties >::ptr v6_CrossSectionReinforcementDefinitions) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_LongitudinalStartPosition)); e->setArgument(1,(v2_LongitudinalEndPosition)); if (v3_TransversePosition) { e->setArgument(2,(*v3_TransversePosition)); } else { e->setArgument(2); } e->setArgument(3,v4_ReinforcementRole,IfcReinforcingBarRoleEnum::ToString(v4_ReinforcementRole)); e->setArgument(4,(v5_SectionDefinition)); e->setArgument(5,(v6_CrossSectionReinforcementDefinitions)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSectionedSpine -IfcCompositeCurve* IfcSectionedSpine::SpineCurve() const { return (IfcCompositeCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcSectionedSpine::setSpineCurve(IfcCompositeCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcTemplatedEntityList< IfcProfileDef >::ptr IfcSectionedSpine::CrossSections() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcSectionedSpine::setCrossSections(IfcTemplatedEntityList< IfcProfileDef >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -IfcTemplatedEntityList< IfcAxis2Placement3D >::ptr IfcSectionedSpine::CrossSectionPositions() const { IfcEntityList::ptr es = *entity->getArgument(2); return es->as(); } -void IfcSectionedSpine::setCrossSectionPositions(IfcTemplatedEntityList< IfcAxis2Placement3D >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v->generalize()); } -bool IfcSectionedSpine::is(Type::Enum v) const { return v == Type::IfcSectionedSpine || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcSectionedSpine::type() const { return Type::IfcSectionedSpine; } +IfcCompositeCurve* IfcSectionedSpine::SpineCurve() const { return (IfcCompositeCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcSectionedSpine::setSpineCurve(IfcCompositeCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcTemplatedEntityList< IfcProfileDef >::ptr IfcSectionedSpine::CrossSections() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcSectionedSpine::setCrossSections(IfcTemplatedEntityList< IfcProfileDef >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +IfcTemplatedEntityList< IfcAxis2Placement3D >::ptr IfcSectionedSpine::CrossSectionPositions() const { IfcEntityList::ptr es = *data_->getArgument(2); return es->as(); } +void IfcSectionedSpine::setCrossSectionPositions(IfcTemplatedEntityList< IfcAxis2Placement3D >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v->generalize()); } + + +const IfcParse::entity& IfcSectionedSpine::declaration() const { return *IfcSectionedSpine_type; } Type::Enum IfcSectionedSpine::Class() { return Type::IfcSectionedSpine; } -IfcSectionedSpine::IfcSectionedSpine(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSectionedSpine)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSectionedSpine::IfcSectionedSpine(IfcCompositeCurve* v1_SpineCurve, IfcTemplatedEntityList< IfcProfileDef >::ptr v2_CrossSections, IfcTemplatedEntityList< IfcAxis2Placement3D >::ptr v3_CrossSectionPositions) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SpineCurve)); e->setArgument(1,(v2_CrossSections)->generalize()); e->setArgument(2,(v3_CrossSectionPositions)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcSectionedSpine::IfcSectionedSpine(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSectionedSpine)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSectionedSpine::IfcSectionedSpine(IfcCompositeCurve* v1_SpineCurve, IfcTemplatedEntityList< IfcProfileDef >::ptr v2_CrossSections, IfcTemplatedEntityList< IfcAxis2Placement3D >::ptr v3_CrossSectionPositions) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SpineCurve)); e->setArgument(1,(v2_CrossSections)->generalize()); e->setArgument(2,(v3_CrossSectionPositions)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSensorType -IfcSensorTypeEnum::IfcSensorTypeEnum IfcSensorType::PredefinedType() const { return IfcSensorTypeEnum::FromString(*entity->getArgument(9)); } -void IfcSensorType::setPredefinedType(IfcSensorTypeEnum::IfcSensorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcSensorTypeEnum::ToString(v)); } -bool IfcSensorType::is(Type::Enum v) const { return v == Type::IfcSensorType || IfcDistributionControlElementType::is(v); } -Type::Enum IfcSensorType::type() const { return Type::IfcSensorType; } +IfcSensorTypeEnum::IfcSensorTypeEnum IfcSensorType::PredefinedType() const { return IfcSensorTypeEnum::FromString(*data_->getArgument(9)); } +void IfcSensorType::setPredefinedType(IfcSensorTypeEnum::IfcSensorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcSensorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSensorType::declaration() const { return *IfcSensorType_type; } Type::Enum IfcSensorType::Class() { return Type::IfcSensorType; } -IfcSensorType::IfcSensorType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSensorType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSensorType::IfcSensorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSensorTypeEnum::IfcSensorTypeEnum v10_PredefinedType) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSensorTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcSensorType::IfcSensorType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSensorType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSensorType::IfcSensorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSensorTypeEnum::IfcSensorTypeEnum v10_PredefinedType) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSensorTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcServiceLife -IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum IfcServiceLife::ServiceLifeType() const { return IfcServiceLifeTypeEnum::FromString(*entity->getArgument(5)); } -void IfcServiceLife::setServiceLifeType(IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcServiceLifeTypeEnum::ToString(v)); } -double IfcServiceLife::ServiceLifeDuration() const { return *entity->getArgument(6); } -void IfcServiceLife::setServiceLifeDuration(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcServiceLife::is(Type::Enum v) const { return v == Type::IfcServiceLife || IfcControl::is(v); } -Type::Enum IfcServiceLife::type() const { return Type::IfcServiceLife; } +IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum IfcServiceLife::ServiceLifeType() const { return IfcServiceLifeTypeEnum::FromString(*data_->getArgument(5)); } +void IfcServiceLife::setServiceLifeType(IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcServiceLifeTypeEnum::ToString(v)); } +double IfcServiceLife::ServiceLifeDuration() const { return *data_->getArgument(6); } +void IfcServiceLife::setServiceLifeDuration(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcServiceLife::declaration() const { return *IfcServiceLife_type; } Type::Enum IfcServiceLife::Class() { return Type::IfcServiceLife; } -IfcServiceLife::IfcServiceLife(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcServiceLife)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcServiceLife::IfcServiceLife(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum v6_ServiceLifeType, double v7_ServiceLifeDuration) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,v6_ServiceLifeType,IfcServiceLifeTypeEnum::ToString(v6_ServiceLifeType)); e->setArgument(6,(v7_ServiceLifeDuration)); entity = e; EntityBuffer::Add(this); } +IfcServiceLife::IfcServiceLife(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcServiceLife)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcServiceLife::IfcServiceLife(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum v6_ServiceLifeType, double v7_ServiceLifeDuration) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,v6_ServiceLifeType,IfcServiceLifeTypeEnum::ToString(v6_ServiceLifeType)); e->setArgument(6,(v7_ServiceLifeDuration)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcServiceLifeFactor -IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum IfcServiceLifeFactor::PredefinedType() const { return IfcServiceLifeFactorTypeEnum::FromString(*entity->getArgument(4)); } -void IfcServiceLifeFactor::setPredefinedType(IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcServiceLifeFactorTypeEnum::ToString(v)); } -bool IfcServiceLifeFactor::hasUpperValue() const { return !entity->getArgument(5)->isNull(); } -IfcMeasureValue* IfcServiceLifeFactor::UpperValue() const { return (IfcMeasureValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcServiceLifeFactor::setUpperValue(IfcMeasureValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcMeasureValue* IfcServiceLifeFactor::MostUsedValue() const { return (IfcMeasureValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcServiceLifeFactor::setMostUsedValue(IfcMeasureValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcServiceLifeFactor::hasLowerValue() const { return !entity->getArgument(7)->isNull(); } -IfcMeasureValue* IfcServiceLifeFactor::LowerValue() const { return (IfcMeasureValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcServiceLifeFactor::setLowerValue(IfcMeasureValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcServiceLifeFactor::is(Type::Enum v) const { return v == Type::IfcServiceLifeFactor || IfcPropertySetDefinition::is(v); } -Type::Enum IfcServiceLifeFactor::type() const { return Type::IfcServiceLifeFactor; } +IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum IfcServiceLifeFactor::PredefinedType() const { return IfcServiceLifeFactorTypeEnum::FromString(*data_->getArgument(4)); } +void IfcServiceLifeFactor::setPredefinedType(IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcServiceLifeFactorTypeEnum::ToString(v)); } +bool IfcServiceLifeFactor::hasUpperValue() const { return !data_->getArgument(5)->isNull(); } +IfcMeasureValue* IfcServiceLifeFactor::UpperValue() const { return (IfcMeasureValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcServiceLifeFactor::setUpperValue(IfcMeasureValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +IfcMeasureValue* IfcServiceLifeFactor::MostUsedValue() const { return (IfcMeasureValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcServiceLifeFactor::setMostUsedValue(IfcMeasureValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcServiceLifeFactor::hasLowerValue() const { return !data_->getArgument(7)->isNull(); } +IfcMeasureValue* IfcServiceLifeFactor::LowerValue() const { return (IfcMeasureValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcServiceLifeFactor::setLowerValue(IfcMeasureValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcServiceLifeFactor::declaration() const { return *IfcServiceLifeFactor_type; } Type::Enum IfcServiceLifeFactor::Class() { return Type::IfcServiceLifeFactor; } -IfcServiceLifeFactor::IfcServiceLifeFactor(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcServiceLifeFactor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcServiceLifeFactor::IfcServiceLifeFactor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum v5_PredefinedType, IfcMeasureValue* v6_UpperValue, IfcMeasureValue* v7_MostUsedValue, IfcMeasureValue* v8_LowerValue) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,v5_PredefinedType,IfcServiceLifeFactorTypeEnum::ToString(v5_PredefinedType)); e->setArgument(5,(v6_UpperValue)); e->setArgument(6,(v7_MostUsedValue)); e->setArgument(7,(v8_LowerValue)); entity = e; EntityBuffer::Add(this); } +IfcServiceLifeFactor::IfcServiceLifeFactor(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcServiceLifeFactor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcServiceLifeFactor::IfcServiceLifeFactor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum v5_PredefinedType, IfcMeasureValue* v6_UpperValue, IfcMeasureValue* v7_MostUsedValue, IfcMeasureValue* v8_LowerValue) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,v5_PredefinedType,IfcServiceLifeFactorTypeEnum::ToString(v5_PredefinedType)); e->setArgument(5,(v6_UpperValue)); e->setArgument(6,(v7_MostUsedValue)); e->setArgument(7,(v8_LowerValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcShapeAspect -IfcTemplatedEntityList< IfcShapeModel >::ptr IfcShapeAspect::ShapeRepresentations() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcShapeAspect::setShapeRepresentations(IfcTemplatedEntityList< IfcShapeModel >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcShapeAspect::hasName() const { return !entity->getArgument(1)->isNull(); } -std::string IfcShapeAspect::Name() const { return *entity->getArgument(1); } -void IfcShapeAspect::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcShapeAspect::hasDescription() const { return !entity->getArgument(2)->isNull(); } -std::string IfcShapeAspect::Description() const { return *entity->getArgument(2); } -void IfcShapeAspect::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcShapeAspect::ProductDefinitional() const { return *entity->getArgument(3); } -void IfcShapeAspect::setProductDefinitional(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -IfcProductDefinitionShape* IfcShapeAspect::PartOfProductDefinitionShape() const { return (IfcProductDefinitionShape*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcShapeAspect::setPartOfProductDefinitionShape(IfcProductDefinitionShape* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcShapeAspect::is(Type::Enum v) const { return v == Type::IfcShapeAspect; } -Type::Enum IfcShapeAspect::type() const { return Type::IfcShapeAspect; } +IfcTemplatedEntityList< IfcShapeModel >::ptr IfcShapeAspect::ShapeRepresentations() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcShapeAspect::setShapeRepresentations(IfcTemplatedEntityList< IfcShapeModel >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } +bool IfcShapeAspect::hasName() const { return !data_->getArgument(1)->isNull(); } +std::string IfcShapeAspect::Name() const { return *data_->getArgument(1); } +void IfcShapeAspect::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcShapeAspect::hasDescription() const { return !data_->getArgument(2)->isNull(); } +std::string IfcShapeAspect::Description() const { return *data_->getArgument(2); } +void IfcShapeAspect::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcShapeAspect::ProductDefinitional() const { return *data_->getArgument(3); } +void IfcShapeAspect::setProductDefinitional(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +IfcProductDefinitionShape* IfcShapeAspect::PartOfProductDefinitionShape() const { return (IfcProductDefinitionShape*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcShapeAspect::setPartOfProductDefinitionShape(IfcProductDefinitionShape* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcShapeAspect::declaration() const { return *IfcShapeAspect_type; } Type::Enum IfcShapeAspect::Class() { return Type::IfcShapeAspect; } -IfcShapeAspect::IfcShapeAspect(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcShapeAspect)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcShapeAspect::IfcShapeAspect(IfcTemplatedEntityList< IfcShapeModel >::ptr v1_ShapeRepresentations, boost::optional< std::string > v2_Name, boost::optional< std::string > v3_Description, bool v4_ProductDefinitional, IfcProductDefinitionShape* v5_PartOfProductDefinitionShape) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ShapeRepresentations)->generalize()); if (v2_Name) { e->setArgument(1,(*v2_Name)); } else { e->setArgument(1); } if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } e->setArgument(3,(v4_ProductDefinitional)); e->setArgument(4,(v5_PartOfProductDefinitionShape)); entity = e; EntityBuffer::Add(this); } +IfcShapeAspect::IfcShapeAspect(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcShapeAspect)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcShapeAspect::IfcShapeAspect(IfcTemplatedEntityList< IfcShapeModel >::ptr v1_ShapeRepresentations, boost::optional< std::string > v2_Name, boost::optional< std::string > v3_Description, bool v4_ProductDefinitional, IfcProductDefinitionShape* v5_PartOfProductDefinitionShape) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ShapeRepresentations)->generalize()); if (v2_Name) { e->setArgument(1,(*v2_Name)); } else { e->setArgument(1); } if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } e->setArgument(3,(v4_ProductDefinitional)); e->setArgument(4,(v5_PartOfProductDefinitionShape)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcShapeModel -IfcShapeAspect::list::ptr IfcShapeModel::OfShapeAspect() const { return entity->getInverse(Type::IfcShapeAspect, 0)->as(); } -bool IfcShapeModel::is(Type::Enum v) const { return v == Type::IfcShapeModel || IfcRepresentation::is(v); } -Type::Enum IfcShapeModel::type() const { return Type::IfcShapeModel; } + +IfcShapeAspect::list::ptr IfcShapeModel::OfShapeAspect() const { return data_->getInverse(Type::IfcShapeAspect, 0)->as(); } + +const IfcParse::entity& IfcShapeModel::declaration() const { return *IfcShapeModel_type; } Type::Enum IfcShapeModel::Class() { return Type::IfcShapeModel; } -IfcShapeModel::IfcShapeModel(IfcAbstractEntity* e) : IfcRepresentation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcShapeModel)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcShapeModel::IfcShapeModel(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcRepresentation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcShapeModel::IfcShapeModel(IfcAbstractEntity* e) : IfcRepresentation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcShapeModel)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcShapeModel::IfcShapeModel(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcRepresentation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcShapeRepresentation -bool IfcShapeRepresentation::is(Type::Enum v) const { return v == Type::IfcShapeRepresentation || IfcShapeModel::is(v); } -Type::Enum IfcShapeRepresentation::type() const { return Type::IfcShapeRepresentation; } + + +const IfcParse::entity& IfcShapeRepresentation::declaration() const { return *IfcShapeRepresentation_type; } Type::Enum IfcShapeRepresentation::Class() { return Type::IfcShapeRepresentation; } -IfcShapeRepresentation::IfcShapeRepresentation(IfcAbstractEntity* e) : IfcShapeModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcShapeRepresentation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcShapeRepresentation::IfcShapeRepresentation(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcShapeModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcShapeRepresentation::IfcShapeRepresentation(IfcAbstractEntity* e) : IfcShapeModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcShapeRepresentation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcShapeRepresentation::IfcShapeRepresentation(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcShapeModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcShellBasedSurfaceModel -IfcEntityList::ptr IfcShellBasedSurfaceModel::SbsmBoundary() const { return *entity->getArgument(0); } -void IfcShellBasedSurfaceModel::setSbsmBoundary(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcShellBasedSurfaceModel::is(Type::Enum v) const { return v == Type::IfcShellBasedSurfaceModel || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcShellBasedSurfaceModel::type() const { return Type::IfcShellBasedSurfaceModel; } +IfcEntityList::ptr IfcShellBasedSurfaceModel::SbsmBoundary() const { return *data_->getArgument(0); } +void IfcShellBasedSurfaceModel::setSbsmBoundary(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcShellBasedSurfaceModel::declaration() const { return *IfcShellBasedSurfaceModel_type; } Type::Enum IfcShellBasedSurfaceModel::Class() { return Type::IfcShellBasedSurfaceModel; } -IfcShellBasedSurfaceModel::IfcShellBasedSurfaceModel(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcShellBasedSurfaceModel)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcShellBasedSurfaceModel::IfcShellBasedSurfaceModel(IfcEntityList::ptr v1_SbsmBoundary) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SbsmBoundary)); entity = e; EntityBuffer::Add(this); } +IfcShellBasedSurfaceModel::IfcShellBasedSurfaceModel(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcShellBasedSurfaceModel)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcShellBasedSurfaceModel::IfcShellBasedSurfaceModel(IfcEntityList::ptr v1_SbsmBoundary) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SbsmBoundary)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSimpleProperty -bool IfcSimpleProperty::is(Type::Enum v) const { return v == Type::IfcSimpleProperty || IfcProperty::is(v); } -Type::Enum IfcSimpleProperty::type() const { return Type::IfcSimpleProperty; } + + +const IfcParse::entity& IfcSimpleProperty::declaration() const { return *IfcSimpleProperty_type; } Type::Enum IfcSimpleProperty::Class() { return Type::IfcSimpleProperty; } -IfcSimpleProperty::IfcSimpleProperty(IfcAbstractEntity* e) : IfcProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSimpleProperty)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSimpleProperty::IfcSimpleProperty(std::string v1_Name, boost::optional< std::string > v2_Description) : IfcProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } entity = e; EntityBuffer::Add(this); } +IfcSimpleProperty::IfcSimpleProperty(IfcAbstractEntity* e) : IfcProperty((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSimpleProperty)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSimpleProperty::IfcSimpleProperty(std::string v1_Name, boost::optional< std::string > v2_Description) : IfcProperty((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSite -bool IfcSite::hasRefLatitude() const { return !entity->getArgument(9)->isNull(); } -std::vector< int > /*[3:4]*/ IfcSite::RefLatitude() const { return *entity->getArgument(9); } -void IfcSite::setRefLatitude(std::vector< int > /*[3:4]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcSite::hasRefLongitude() const { return !entity->getArgument(10)->isNull(); } -std::vector< int > /*[3:4]*/ IfcSite::RefLongitude() const { return *entity->getArgument(10); } -void IfcSite::setRefLongitude(std::vector< int > /*[3:4]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcSite::hasRefElevation() const { return !entity->getArgument(11)->isNull(); } -double IfcSite::RefElevation() const { return *entity->getArgument(11); } -void IfcSite::setRefElevation(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcSite::hasLandTitleNumber() const { return !entity->getArgument(12)->isNull(); } -std::string IfcSite::LandTitleNumber() const { return *entity->getArgument(12); } -void IfcSite::setLandTitleNumber(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcSite::hasSiteAddress() const { return !entity->getArgument(13)->isNull(); } -IfcPostalAddress* IfcSite::SiteAddress() const { return (IfcPostalAddress*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(13))); } -void IfcSite::setSiteAddress(IfcPostalAddress* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcSite::is(Type::Enum v) const { return v == Type::IfcSite || IfcSpatialStructureElement::is(v); } -Type::Enum IfcSite::type() const { return Type::IfcSite; } +bool IfcSite::hasRefLatitude() const { return !data_->getArgument(9)->isNull(); } +std::vector< int > /*[3:4]*/ IfcSite::RefLatitude() const { return *data_->getArgument(9); } +void IfcSite::setRefLatitude(std::vector< int > /*[3:4]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcSite::hasRefLongitude() const { return !data_->getArgument(10)->isNull(); } +std::vector< int > /*[3:4]*/ IfcSite::RefLongitude() const { return *data_->getArgument(10); } +void IfcSite::setRefLongitude(std::vector< int > /*[3:4]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcSite::hasRefElevation() const { return !data_->getArgument(11)->isNull(); } +double IfcSite::RefElevation() const { return *data_->getArgument(11); } +void IfcSite::setRefElevation(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcSite::hasLandTitleNumber() const { return !data_->getArgument(12)->isNull(); } +std::string IfcSite::LandTitleNumber() const { return *data_->getArgument(12); } +void IfcSite::setLandTitleNumber(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcSite::hasSiteAddress() const { return !data_->getArgument(13)->isNull(); } +IfcPostalAddress* IfcSite::SiteAddress() const { return (IfcPostalAddress*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(13))); } +void IfcSite::setSiteAddress(IfcPostalAddress* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } + + +const IfcParse::entity& IfcSite::declaration() const { return *IfcSite_type; } Type::Enum IfcSite::Class() { return Type::IfcSite; } -IfcSite::IfcSite(IfcAbstractEntity* e) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSite)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSite::IfcSite(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, boost::optional< std::vector< int > /*[3:4]*/ > v10_RefLatitude, boost::optional< std::vector< int > /*[3:4]*/ > v11_RefLongitude, boost::optional< double > v12_RefElevation, boost::optional< std::string > v13_LandTitleNumber, IfcPostalAddress* v14_SiteAddress) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_LongName) { e->setArgument(7,(*v8_LongName)); } else { e->setArgument(7); } e->setArgument(8,v9_CompositionType,IfcElementCompositionEnum::ToString(v9_CompositionType)); if (v10_RefLatitude) { e->setArgument(9,(*v10_RefLatitude)); } else { e->setArgument(9); } if (v11_RefLongitude) { e->setArgument(10,(*v11_RefLongitude)); } else { e->setArgument(10); } if (v12_RefElevation) { e->setArgument(11,(*v12_RefElevation)); } else { e->setArgument(11); } if (v13_LandTitleNumber) { e->setArgument(12,(*v13_LandTitleNumber)); } else { e->setArgument(12); } e->setArgument(13,(v14_SiteAddress)); entity = e; EntityBuffer::Add(this); } +IfcSite::IfcSite(IfcAbstractEntity* e) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSite)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSite::IfcSite(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, boost::optional< std::vector< int > /*[3:4]*/ > v10_RefLatitude, boost::optional< std::vector< int > /*[3:4]*/ > v11_RefLongitude, boost::optional< double > v12_RefElevation, boost::optional< std::string > v13_LandTitleNumber, IfcPostalAddress* v14_SiteAddress) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_LongName) { e->setArgument(7,(*v8_LongName)); } else { e->setArgument(7); } e->setArgument(8,v9_CompositionType,IfcElementCompositionEnum::ToString(v9_CompositionType)); if (v10_RefLatitude) { e->setArgument(9,(*v10_RefLatitude)); } else { e->setArgument(9); } if (v11_RefLongitude) { e->setArgument(10,(*v11_RefLongitude)); } else { e->setArgument(10); } if (v12_RefElevation) { e->setArgument(11,(*v12_RefElevation)); } else { e->setArgument(11); } if (v13_LandTitleNumber) { e->setArgument(12,(*v13_LandTitleNumber)); } else { e->setArgument(12); } e->setArgument(13,(v14_SiteAddress)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSlab -bool IfcSlab::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcSlabTypeEnum::IfcSlabTypeEnum IfcSlab::PredefinedType() const { return IfcSlabTypeEnum::FromString(*entity->getArgument(8)); } -void IfcSlab::setPredefinedType(IfcSlabTypeEnum::IfcSlabTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcSlabTypeEnum::ToString(v)); } -bool IfcSlab::is(Type::Enum v) const { return v == Type::IfcSlab || IfcBuildingElement::is(v); } -Type::Enum IfcSlab::type() const { return Type::IfcSlab; } +bool IfcSlab::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcSlabTypeEnum::IfcSlabTypeEnum IfcSlab::PredefinedType() const { return IfcSlabTypeEnum::FromString(*data_->getArgument(8)); } +void IfcSlab::setPredefinedType(IfcSlabTypeEnum::IfcSlabTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcSlabTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSlab::declaration() const { return *IfcSlab_type; } Type::Enum IfcSlab::Class() { return Type::IfcSlab; } -IfcSlab::IfcSlab(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSlab)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSlab::IfcSlab(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcSlabTypeEnum::IfcSlabTypeEnum > v9_PredefinedType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcSlabTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSlab::IfcSlab(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSlab)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSlab::IfcSlab(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcSlabTypeEnum::IfcSlabTypeEnum > v9_PredefinedType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcSlabTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSlabType -IfcSlabTypeEnum::IfcSlabTypeEnum IfcSlabType::PredefinedType() const { return IfcSlabTypeEnum::FromString(*entity->getArgument(9)); } -void IfcSlabType::setPredefinedType(IfcSlabTypeEnum::IfcSlabTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcSlabTypeEnum::ToString(v)); } -bool IfcSlabType::is(Type::Enum v) const { return v == Type::IfcSlabType || IfcBuildingElementType::is(v); } -Type::Enum IfcSlabType::type() const { return Type::IfcSlabType; } +IfcSlabTypeEnum::IfcSlabTypeEnum IfcSlabType::PredefinedType() const { return IfcSlabTypeEnum::FromString(*data_->getArgument(9)); } +void IfcSlabType::setPredefinedType(IfcSlabTypeEnum::IfcSlabTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcSlabTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSlabType::declaration() const { return *IfcSlabType_type; } Type::Enum IfcSlabType::Class() { return Type::IfcSlabType; } -IfcSlabType::IfcSlabType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSlabType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSlabType::IfcSlabType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSlabTypeEnum::IfcSlabTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSlabTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcSlabType::IfcSlabType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSlabType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSlabType::IfcSlabType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSlabTypeEnum::IfcSlabTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSlabTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSlippageConnectionCondition -bool IfcSlippageConnectionCondition::hasSlippageX() const { return !entity->getArgument(1)->isNull(); } -double IfcSlippageConnectionCondition::SlippageX() const { return *entity->getArgument(1); } -void IfcSlippageConnectionCondition::setSlippageX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcSlippageConnectionCondition::hasSlippageY() const { return !entity->getArgument(2)->isNull(); } -double IfcSlippageConnectionCondition::SlippageY() const { return *entity->getArgument(2); } -void IfcSlippageConnectionCondition::setSlippageY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcSlippageConnectionCondition::hasSlippageZ() const { return !entity->getArgument(3)->isNull(); } -double IfcSlippageConnectionCondition::SlippageZ() const { return *entity->getArgument(3); } -void IfcSlippageConnectionCondition::setSlippageZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcSlippageConnectionCondition::is(Type::Enum v) const { return v == Type::IfcSlippageConnectionCondition || IfcStructuralConnectionCondition::is(v); } -Type::Enum IfcSlippageConnectionCondition::type() const { return Type::IfcSlippageConnectionCondition; } +bool IfcSlippageConnectionCondition::hasSlippageX() const { return !data_->getArgument(1)->isNull(); } +double IfcSlippageConnectionCondition::SlippageX() const { return *data_->getArgument(1); } +void IfcSlippageConnectionCondition::setSlippageX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcSlippageConnectionCondition::hasSlippageY() const { return !data_->getArgument(2)->isNull(); } +double IfcSlippageConnectionCondition::SlippageY() const { return *data_->getArgument(2); } +void IfcSlippageConnectionCondition::setSlippageY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcSlippageConnectionCondition::hasSlippageZ() const { return !data_->getArgument(3)->isNull(); } +double IfcSlippageConnectionCondition::SlippageZ() const { return *data_->getArgument(3); } +void IfcSlippageConnectionCondition::setSlippageZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcSlippageConnectionCondition::declaration() const { return *IfcSlippageConnectionCondition_type; } Type::Enum IfcSlippageConnectionCondition::Class() { return Type::IfcSlippageConnectionCondition; } -IfcSlippageConnectionCondition::IfcSlippageConnectionCondition(IfcAbstractEntity* e) : IfcStructuralConnectionCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSlippageConnectionCondition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSlippageConnectionCondition::IfcSlippageConnectionCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_SlippageX, boost::optional< double > v3_SlippageY, boost::optional< double > v4_SlippageZ) : IfcStructuralConnectionCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_SlippageX) { e->setArgument(1,(*v2_SlippageX)); } else { e->setArgument(1); } if (v3_SlippageY) { e->setArgument(2,(*v3_SlippageY)); } else { e->setArgument(2); } if (v4_SlippageZ) { e->setArgument(3,(*v4_SlippageZ)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcSlippageConnectionCondition::IfcSlippageConnectionCondition(IfcAbstractEntity* e) : IfcStructuralConnectionCondition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSlippageConnectionCondition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSlippageConnectionCondition::IfcSlippageConnectionCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_SlippageX, boost::optional< double > v3_SlippageY, boost::optional< double > v4_SlippageZ) : IfcStructuralConnectionCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_SlippageX) { e->setArgument(1,(*v2_SlippageX)); } else { e->setArgument(1); } if (v3_SlippageY) { e->setArgument(2,(*v3_SlippageY)); } else { e->setArgument(2); } if (v4_SlippageZ) { e->setArgument(3,(*v4_SlippageZ)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSolidModel -bool IfcSolidModel::is(Type::Enum v) const { return v == Type::IfcSolidModel || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcSolidModel::type() const { return Type::IfcSolidModel; } + + +const IfcParse::entity& IfcSolidModel::declaration() const { return *IfcSolidModel_type; } Type::Enum IfcSolidModel::Class() { return Type::IfcSolidModel; } -IfcSolidModel::IfcSolidModel(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSolidModel)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSolidModel::IfcSolidModel() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcSolidModel::IfcSolidModel(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSolidModel)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSolidModel::IfcSolidModel() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSoundProperties -bool IfcSoundProperties::IsAttenuating() const { return *entity->getArgument(4); } -void IfcSoundProperties::setIsAttenuating(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcSoundProperties::hasSoundScale() const { return !entity->getArgument(5)->isNull(); } -IfcSoundScaleEnum::IfcSoundScaleEnum IfcSoundProperties::SoundScale() const { return IfcSoundScaleEnum::FromString(*entity->getArgument(5)); } -void IfcSoundProperties::setSoundScale(IfcSoundScaleEnum::IfcSoundScaleEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcSoundScaleEnum::ToString(v)); } -IfcTemplatedEntityList< IfcSoundValue >::ptr IfcSoundProperties::SoundValues() const { IfcEntityList::ptr es = *entity->getArgument(6); return es->as(); } -void IfcSoundProperties::setSoundValues(IfcTemplatedEntityList< IfcSoundValue >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v->generalize()); } -bool IfcSoundProperties::is(Type::Enum v) const { return v == Type::IfcSoundProperties || IfcPropertySetDefinition::is(v); } -Type::Enum IfcSoundProperties::type() const { return Type::IfcSoundProperties; } +bool IfcSoundProperties::IsAttenuating() const { return *data_->getArgument(4); } +void IfcSoundProperties::setIsAttenuating(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcSoundProperties::hasSoundScale() const { return !data_->getArgument(5)->isNull(); } +IfcSoundScaleEnum::IfcSoundScaleEnum IfcSoundProperties::SoundScale() const { return IfcSoundScaleEnum::FromString(*data_->getArgument(5)); } +void IfcSoundProperties::setSoundScale(IfcSoundScaleEnum::IfcSoundScaleEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcSoundScaleEnum::ToString(v)); } +IfcTemplatedEntityList< IfcSoundValue >::ptr IfcSoundProperties::SoundValues() const { IfcEntityList::ptr es = *data_->getArgument(6); return es->as(); } +void IfcSoundProperties::setSoundValues(IfcTemplatedEntityList< IfcSoundValue >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v->generalize()); } + + +const IfcParse::entity& IfcSoundProperties::declaration() const { return *IfcSoundProperties_type; } Type::Enum IfcSoundProperties::Class() { return Type::IfcSoundProperties; } -IfcSoundProperties::IfcSoundProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSoundProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSoundProperties::IfcSoundProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, bool v5_IsAttenuating, boost::optional< IfcSoundScaleEnum::IfcSoundScaleEnum > v6_SoundScale, IfcTemplatedEntityList< IfcSoundValue >::ptr v7_SoundValues) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_IsAttenuating)); if (v6_SoundScale) { e->setArgument(5,*v6_SoundScale,IfcSoundScaleEnum::ToString(*v6_SoundScale)); } else { e->setArgument(5); } e->setArgument(6,(v7_SoundValues)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcSoundProperties::IfcSoundProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSoundProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSoundProperties::IfcSoundProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, bool v5_IsAttenuating, boost::optional< IfcSoundScaleEnum::IfcSoundScaleEnum > v6_SoundScale, IfcTemplatedEntityList< IfcSoundValue >::ptr v7_SoundValues) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_IsAttenuating)); if (v6_SoundScale) { e->setArgument(5,*v6_SoundScale,IfcSoundScaleEnum::ToString(*v6_SoundScale)); } else { e->setArgument(5); } e->setArgument(6,(v7_SoundValues)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSoundValue -bool IfcSoundValue::hasSoundLevelTimeSeries() const { return !entity->getArgument(4)->isNull(); } -IfcTimeSeries* IfcSoundValue::SoundLevelTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcSoundValue::setSoundLevelTimeSeries(IfcTimeSeries* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -double IfcSoundValue::Frequency() const { return *entity->getArgument(5); } -void IfcSoundValue::setFrequency(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcSoundValue::hasSoundLevelSingleValue() const { return !entity->getArgument(6)->isNull(); } -IfcDerivedMeasureValue* IfcSoundValue::SoundLevelSingleValue() const { return (IfcDerivedMeasureValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcSoundValue::setSoundLevelSingleValue(IfcDerivedMeasureValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcSoundValue::is(Type::Enum v) const { return v == Type::IfcSoundValue || IfcPropertySetDefinition::is(v); } -Type::Enum IfcSoundValue::type() const { return Type::IfcSoundValue; } +bool IfcSoundValue::hasSoundLevelTimeSeries() const { return !data_->getArgument(4)->isNull(); } +IfcTimeSeries* IfcSoundValue::SoundLevelTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcSoundValue::setSoundLevelTimeSeries(IfcTimeSeries* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +double IfcSoundValue::Frequency() const { return *data_->getArgument(5); } +void IfcSoundValue::setFrequency(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcSoundValue::hasSoundLevelSingleValue() const { return !data_->getArgument(6)->isNull(); } +IfcDerivedMeasureValue* IfcSoundValue::SoundLevelSingleValue() const { return (IfcDerivedMeasureValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcSoundValue::setSoundLevelSingleValue(IfcDerivedMeasureValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcSoundValue::declaration() const { return *IfcSoundValue_type; } Type::Enum IfcSoundValue::Class() { return Type::IfcSoundValue; } -IfcSoundValue::IfcSoundValue(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSoundValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSoundValue::IfcSoundValue(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTimeSeries* v5_SoundLevelTimeSeries, double v6_Frequency, IfcDerivedMeasureValue* v7_SoundLevelSingleValue) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_SoundLevelTimeSeries)); e->setArgument(5,(v6_Frequency)); e->setArgument(6,(v7_SoundLevelSingleValue)); entity = e; EntityBuffer::Add(this); } +IfcSoundValue::IfcSoundValue(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSoundValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSoundValue::IfcSoundValue(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTimeSeries* v5_SoundLevelTimeSeries, double v6_Frequency, IfcDerivedMeasureValue* v7_SoundLevelSingleValue) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,(v5_SoundLevelTimeSeries)); e->setArgument(5,(v6_Frequency)); e->setArgument(6,(v7_SoundLevelSingleValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpace -IfcInternalOrExternalEnum::IfcInternalOrExternalEnum IfcSpace::InteriorOrExteriorSpace() const { return IfcInternalOrExternalEnum::FromString(*entity->getArgument(9)); } -void IfcSpace::setInteriorOrExteriorSpace(IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcInternalOrExternalEnum::ToString(v)); } -bool IfcSpace::hasElevationWithFlooring() const { return !entity->getArgument(10)->isNull(); } -double IfcSpace::ElevationWithFlooring() const { return *entity->getArgument(10); } -void IfcSpace::setElevationWithFlooring(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -IfcRelCoversSpaces::list::ptr IfcSpace::HasCoverings() const { return entity->getInverse(Type::IfcRelCoversSpaces, 4)->as(); } -IfcRelSpaceBoundary::list::ptr IfcSpace::BoundedBy() const { return entity->getInverse(Type::IfcRelSpaceBoundary, 4)->as(); } -bool IfcSpace::is(Type::Enum v) const { return v == Type::IfcSpace || IfcSpatialStructureElement::is(v); } -Type::Enum IfcSpace::type() const { return Type::IfcSpace; } +IfcInternalOrExternalEnum::IfcInternalOrExternalEnum IfcSpace::InteriorOrExteriorSpace() const { return IfcInternalOrExternalEnum::FromString(*data_->getArgument(9)); } +void IfcSpace::setInteriorOrExteriorSpace(IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcInternalOrExternalEnum::ToString(v)); } +bool IfcSpace::hasElevationWithFlooring() const { return !data_->getArgument(10)->isNull(); } +double IfcSpace::ElevationWithFlooring() const { return *data_->getArgument(10); } +void IfcSpace::setElevationWithFlooring(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + +IfcRelCoversSpaces::list::ptr IfcSpace::HasCoverings() const { return data_->getInverse(Type::IfcRelCoversSpaces, 4)->as(); } +IfcRelSpaceBoundary::list::ptr IfcSpace::BoundedBy() const { return data_->getInverse(Type::IfcRelSpaceBoundary, 4)->as(); } + +const IfcParse::entity& IfcSpace::declaration() const { return *IfcSpace_type; } Type::Enum IfcSpace::Class() { return Type::IfcSpace; } -IfcSpace::IfcSpace(IfcAbstractEntity* e) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpace)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpace::IfcSpace(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v10_InteriorOrExteriorSpace, boost::optional< double > v11_ElevationWithFlooring) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_LongName) { e->setArgument(7,(*v8_LongName)); } else { e->setArgument(7); } e->setArgument(8,v9_CompositionType,IfcElementCompositionEnum::ToString(v9_CompositionType)); e->setArgument(9,v10_InteriorOrExteriorSpace,IfcInternalOrExternalEnum::ToString(v10_InteriorOrExteriorSpace)); if (v11_ElevationWithFlooring) { e->setArgument(10,(*v11_ElevationWithFlooring)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcSpace::IfcSpace(IfcAbstractEntity* e) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpace)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpace::IfcSpace(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v10_InteriorOrExteriorSpace, boost::optional< double > v11_ElevationWithFlooring) : IfcSpatialStructureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_LongName) { e->setArgument(7,(*v8_LongName)); } else { e->setArgument(7); } e->setArgument(8,v9_CompositionType,IfcElementCompositionEnum::ToString(v9_CompositionType)); e->setArgument(9,v10_InteriorOrExteriorSpace,IfcInternalOrExternalEnum::ToString(v10_InteriorOrExteriorSpace)); if (v11_ElevationWithFlooring) { e->setArgument(10,(*v11_ElevationWithFlooring)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpaceHeaterType -IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum IfcSpaceHeaterType::PredefinedType() const { return IfcSpaceHeaterTypeEnum::FromString(*entity->getArgument(9)); } -void IfcSpaceHeaterType::setPredefinedType(IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcSpaceHeaterTypeEnum::ToString(v)); } -bool IfcSpaceHeaterType::is(Type::Enum v) const { return v == Type::IfcSpaceHeaterType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcSpaceHeaterType::type() const { return Type::IfcSpaceHeaterType; } +IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum IfcSpaceHeaterType::PredefinedType() const { return IfcSpaceHeaterTypeEnum::FromString(*data_->getArgument(9)); } +void IfcSpaceHeaterType::setPredefinedType(IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcSpaceHeaterTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSpaceHeaterType::declaration() const { return *IfcSpaceHeaterType_type; } Type::Enum IfcSpaceHeaterType::Class() { return Type::IfcSpaceHeaterType; } -IfcSpaceHeaterType::IfcSpaceHeaterType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpaceHeaterType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpaceHeaterType::IfcSpaceHeaterType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSpaceHeaterTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcSpaceHeaterType::IfcSpaceHeaterType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpaceHeaterType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpaceHeaterType::IfcSpaceHeaterType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSpaceHeaterTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpaceProgram -std::string IfcSpaceProgram::SpaceProgramIdentifier() const { return *entity->getArgument(5); } -void IfcSpaceProgram::setSpaceProgramIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcSpaceProgram::hasMaxRequiredArea() const { return !entity->getArgument(6)->isNull(); } -double IfcSpaceProgram::MaxRequiredArea() const { return *entity->getArgument(6); } -void IfcSpaceProgram::setMaxRequiredArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcSpaceProgram::hasMinRequiredArea() const { return !entity->getArgument(7)->isNull(); } -double IfcSpaceProgram::MinRequiredArea() const { return *entity->getArgument(7); } -void IfcSpaceProgram::setMinRequiredArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcSpaceProgram::hasRequestedLocation() const { return !entity->getArgument(8)->isNull(); } -IfcSpatialStructureElement* IfcSpaceProgram::RequestedLocation() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcSpaceProgram::setRequestedLocation(IfcSpatialStructureElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -double IfcSpaceProgram::StandardRequiredArea() const { return *entity->getArgument(9); } -void IfcSpaceProgram::setStandardRequiredArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -IfcRelInteractionRequirements::list::ptr IfcSpaceProgram::HasInteractionReqsFrom() const { return entity->getInverse(Type::IfcRelInteractionRequirements, 7)->as(); } -IfcRelInteractionRequirements::list::ptr IfcSpaceProgram::HasInteractionReqsTo() const { return entity->getInverse(Type::IfcRelInteractionRequirements, 8)->as(); } -bool IfcSpaceProgram::is(Type::Enum v) const { return v == Type::IfcSpaceProgram || IfcControl::is(v); } -Type::Enum IfcSpaceProgram::type() const { return Type::IfcSpaceProgram; } +std::string IfcSpaceProgram::SpaceProgramIdentifier() const { return *data_->getArgument(5); } +void IfcSpaceProgram::setSpaceProgramIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcSpaceProgram::hasMaxRequiredArea() const { return !data_->getArgument(6)->isNull(); } +double IfcSpaceProgram::MaxRequiredArea() const { return *data_->getArgument(6); } +void IfcSpaceProgram::setMaxRequiredArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcSpaceProgram::hasMinRequiredArea() const { return !data_->getArgument(7)->isNull(); } +double IfcSpaceProgram::MinRequiredArea() const { return *data_->getArgument(7); } +void IfcSpaceProgram::setMinRequiredArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcSpaceProgram::hasRequestedLocation() const { return !data_->getArgument(8)->isNull(); } +IfcSpatialStructureElement* IfcSpaceProgram::RequestedLocation() const { return (IfcSpatialStructureElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcSpaceProgram::setRequestedLocation(IfcSpatialStructureElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +double IfcSpaceProgram::StandardRequiredArea() const { return *data_->getArgument(9); } +void IfcSpaceProgram::setStandardRequiredArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + +IfcRelInteractionRequirements::list::ptr IfcSpaceProgram::HasInteractionReqsFrom() const { return data_->getInverse(Type::IfcRelInteractionRequirements, 7)->as(); } +IfcRelInteractionRequirements::list::ptr IfcSpaceProgram::HasInteractionReqsTo() const { return data_->getInverse(Type::IfcRelInteractionRequirements, 8)->as(); } + +const IfcParse::entity& IfcSpaceProgram::declaration() const { return *IfcSpaceProgram_type; } Type::Enum IfcSpaceProgram::Class() { return Type::IfcSpaceProgram; } -IfcSpaceProgram::IfcSpaceProgram(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpaceProgram)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpaceProgram::IfcSpaceProgram(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_SpaceProgramIdentifier, boost::optional< double > v7_MaxRequiredArea, boost::optional< double > v8_MinRequiredArea, IfcSpatialStructureElement* v9_RequestedLocation, double v10_StandardRequiredArea) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_SpaceProgramIdentifier)); if (v7_MaxRequiredArea) { e->setArgument(6,(*v7_MaxRequiredArea)); } else { e->setArgument(6); } if (v8_MinRequiredArea) { e->setArgument(7,(*v8_MinRequiredArea)); } else { e->setArgument(7); } e->setArgument(8,(v9_RequestedLocation)); e->setArgument(9,(v10_StandardRequiredArea)); entity = e; EntityBuffer::Add(this); } +IfcSpaceProgram::IfcSpaceProgram(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpaceProgram)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpaceProgram::IfcSpaceProgram(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_SpaceProgramIdentifier, boost::optional< double > v7_MaxRequiredArea, boost::optional< double > v8_MinRequiredArea, IfcSpatialStructureElement* v9_RequestedLocation, double v10_StandardRequiredArea) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_SpaceProgramIdentifier)); if (v7_MaxRequiredArea) { e->setArgument(6,(*v7_MaxRequiredArea)); } else { e->setArgument(6); } if (v8_MinRequiredArea) { e->setArgument(7,(*v8_MinRequiredArea)); } else { e->setArgument(7); } e->setArgument(8,(v9_RequestedLocation)); e->setArgument(9,(v10_StandardRequiredArea)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpaceThermalLoadProperties -bool IfcSpaceThermalLoadProperties::hasApplicableValueRatio() const { return !entity->getArgument(4)->isNull(); } -double IfcSpaceThermalLoadProperties::ApplicableValueRatio() const { return *entity->getArgument(4); } -void IfcSpaceThermalLoadProperties::setApplicableValueRatio(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum IfcSpaceThermalLoadProperties::ThermalLoadSource() const { return IfcThermalLoadSourceEnum::FromString(*entity->getArgument(5)); } -void IfcSpaceThermalLoadProperties::setThermalLoadSource(IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcThermalLoadSourceEnum::ToString(v)); } -IfcPropertySourceEnum::IfcPropertySourceEnum IfcSpaceThermalLoadProperties::PropertySource() const { return IfcPropertySourceEnum::FromString(*entity->getArgument(6)); } -void IfcSpaceThermalLoadProperties::setPropertySource(IfcPropertySourceEnum::IfcPropertySourceEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcPropertySourceEnum::ToString(v)); } -bool IfcSpaceThermalLoadProperties::hasSourceDescription() const { return !entity->getArgument(7)->isNull(); } -std::string IfcSpaceThermalLoadProperties::SourceDescription() const { return *entity->getArgument(7); } -void IfcSpaceThermalLoadProperties::setSourceDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -double IfcSpaceThermalLoadProperties::MaximumValue() const { return *entity->getArgument(8); } -void IfcSpaceThermalLoadProperties::setMaximumValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcSpaceThermalLoadProperties::hasMinimumValue() const { return !entity->getArgument(9)->isNull(); } -double IfcSpaceThermalLoadProperties::MinimumValue() const { return *entity->getArgument(9); } -void IfcSpaceThermalLoadProperties::setMinimumValue(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcSpaceThermalLoadProperties::hasThermalLoadTimeSeriesValues() const { return !entity->getArgument(10)->isNull(); } -IfcTimeSeries* IfcSpaceThermalLoadProperties::ThermalLoadTimeSeriesValues() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcSpaceThermalLoadProperties::setThermalLoadTimeSeriesValues(IfcTimeSeries* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcSpaceThermalLoadProperties::hasUserDefinedThermalLoadSource() const { return !entity->getArgument(11)->isNull(); } -std::string IfcSpaceThermalLoadProperties::UserDefinedThermalLoadSource() const { return *entity->getArgument(11); } -void IfcSpaceThermalLoadProperties::setUserDefinedThermalLoadSource(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcSpaceThermalLoadProperties::hasUserDefinedPropertySource() const { return !entity->getArgument(12)->isNull(); } -std::string IfcSpaceThermalLoadProperties::UserDefinedPropertySource() const { return *entity->getArgument(12); } -void IfcSpaceThermalLoadProperties::setUserDefinedPropertySource(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum IfcSpaceThermalLoadProperties::ThermalLoadType() const { return IfcThermalLoadTypeEnum::FromString(*entity->getArgument(13)); } -void IfcSpaceThermalLoadProperties::setThermalLoadType(IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v,IfcThermalLoadTypeEnum::ToString(v)); } -bool IfcSpaceThermalLoadProperties::is(Type::Enum v) const { return v == Type::IfcSpaceThermalLoadProperties || IfcPropertySetDefinition::is(v); } -Type::Enum IfcSpaceThermalLoadProperties::type() const { return Type::IfcSpaceThermalLoadProperties; } +bool IfcSpaceThermalLoadProperties::hasApplicableValueRatio() const { return !data_->getArgument(4)->isNull(); } +double IfcSpaceThermalLoadProperties::ApplicableValueRatio() const { return *data_->getArgument(4); } +void IfcSpaceThermalLoadProperties::setApplicableValueRatio(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum IfcSpaceThermalLoadProperties::ThermalLoadSource() const { return IfcThermalLoadSourceEnum::FromString(*data_->getArgument(5)); } +void IfcSpaceThermalLoadProperties::setThermalLoadSource(IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcThermalLoadSourceEnum::ToString(v)); } +IfcPropertySourceEnum::IfcPropertySourceEnum IfcSpaceThermalLoadProperties::PropertySource() const { return IfcPropertySourceEnum::FromString(*data_->getArgument(6)); } +void IfcSpaceThermalLoadProperties::setPropertySource(IfcPropertySourceEnum::IfcPropertySourceEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcPropertySourceEnum::ToString(v)); } +bool IfcSpaceThermalLoadProperties::hasSourceDescription() const { return !data_->getArgument(7)->isNull(); } +std::string IfcSpaceThermalLoadProperties::SourceDescription() const { return *data_->getArgument(7); } +void IfcSpaceThermalLoadProperties::setSourceDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +double IfcSpaceThermalLoadProperties::MaximumValue() const { return *data_->getArgument(8); } +void IfcSpaceThermalLoadProperties::setMaximumValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcSpaceThermalLoadProperties::hasMinimumValue() const { return !data_->getArgument(9)->isNull(); } +double IfcSpaceThermalLoadProperties::MinimumValue() const { return *data_->getArgument(9); } +void IfcSpaceThermalLoadProperties::setMinimumValue(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcSpaceThermalLoadProperties::hasThermalLoadTimeSeriesValues() const { return !data_->getArgument(10)->isNull(); } +IfcTimeSeries* IfcSpaceThermalLoadProperties::ThermalLoadTimeSeriesValues() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcSpaceThermalLoadProperties::setThermalLoadTimeSeriesValues(IfcTimeSeries* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcSpaceThermalLoadProperties::hasUserDefinedThermalLoadSource() const { return !data_->getArgument(11)->isNull(); } +std::string IfcSpaceThermalLoadProperties::UserDefinedThermalLoadSource() const { return *data_->getArgument(11); } +void IfcSpaceThermalLoadProperties::setUserDefinedThermalLoadSource(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcSpaceThermalLoadProperties::hasUserDefinedPropertySource() const { return !data_->getArgument(12)->isNull(); } +std::string IfcSpaceThermalLoadProperties::UserDefinedPropertySource() const { return *data_->getArgument(12); } +void IfcSpaceThermalLoadProperties::setUserDefinedPropertySource(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum IfcSpaceThermalLoadProperties::ThermalLoadType() const { return IfcThermalLoadTypeEnum::FromString(*data_->getArgument(13)); } +void IfcSpaceThermalLoadProperties::setThermalLoadType(IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v,IfcThermalLoadTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSpaceThermalLoadProperties::declaration() const { return *IfcSpaceThermalLoadProperties_type; } Type::Enum IfcSpaceThermalLoadProperties::Class() { return Type::IfcSpaceThermalLoadProperties; } -IfcSpaceThermalLoadProperties::IfcSpaceThermalLoadProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpaceThermalLoadProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpaceThermalLoadProperties::IfcSpaceThermalLoadProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_ApplicableValueRatio, IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum v6_ThermalLoadSource, IfcPropertySourceEnum::IfcPropertySourceEnum v7_PropertySource, boost::optional< std::string > v8_SourceDescription, double v9_MaximumValue, boost::optional< double > v10_MinimumValue, IfcTimeSeries* v11_ThermalLoadTimeSeriesValues, boost::optional< std::string > v12_UserDefinedThermalLoadSource, boost::optional< std::string > v13_UserDefinedPropertySource, IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum v14_ThermalLoadType) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableValueRatio) { e->setArgument(4,(*v5_ApplicableValueRatio)); } else { e->setArgument(4); } e->setArgument(5,v6_ThermalLoadSource,IfcThermalLoadSourceEnum::ToString(v6_ThermalLoadSource)); e->setArgument(6,v7_PropertySource,IfcPropertySourceEnum::ToString(v7_PropertySource)); if (v8_SourceDescription) { e->setArgument(7,(*v8_SourceDescription)); } else { e->setArgument(7); } e->setArgument(8,(v9_MaximumValue)); if (v10_MinimumValue) { e->setArgument(9,(*v10_MinimumValue)); } else { e->setArgument(9); } e->setArgument(10,(v11_ThermalLoadTimeSeriesValues)); if (v12_UserDefinedThermalLoadSource) { e->setArgument(11,(*v12_UserDefinedThermalLoadSource)); } else { e->setArgument(11); } if (v13_UserDefinedPropertySource) { e->setArgument(12,(*v13_UserDefinedPropertySource)); } else { e->setArgument(12); } e->setArgument(13,v14_ThermalLoadType,IfcThermalLoadTypeEnum::ToString(v14_ThermalLoadType)); entity = e; EntityBuffer::Add(this); } +IfcSpaceThermalLoadProperties::IfcSpaceThermalLoadProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpaceThermalLoadProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpaceThermalLoadProperties::IfcSpaceThermalLoadProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_ApplicableValueRatio, IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum v6_ThermalLoadSource, IfcPropertySourceEnum::IfcPropertySourceEnum v7_PropertySource, boost::optional< std::string > v8_SourceDescription, double v9_MaximumValue, boost::optional< double > v10_MinimumValue, IfcTimeSeries* v11_ThermalLoadTimeSeriesValues, boost::optional< std::string > v12_UserDefinedThermalLoadSource, boost::optional< std::string > v13_UserDefinedPropertySource, IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum v14_ThermalLoadType) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableValueRatio) { e->setArgument(4,(*v5_ApplicableValueRatio)); } else { e->setArgument(4); } e->setArgument(5,v6_ThermalLoadSource,IfcThermalLoadSourceEnum::ToString(v6_ThermalLoadSource)); e->setArgument(6,v7_PropertySource,IfcPropertySourceEnum::ToString(v7_PropertySource)); if (v8_SourceDescription) { e->setArgument(7,(*v8_SourceDescription)); } else { e->setArgument(7); } e->setArgument(8,(v9_MaximumValue)); if (v10_MinimumValue) { e->setArgument(9,(*v10_MinimumValue)); } else { e->setArgument(9); } e->setArgument(10,(v11_ThermalLoadTimeSeriesValues)); if (v12_UserDefinedThermalLoadSource) { e->setArgument(11,(*v12_UserDefinedThermalLoadSource)); } else { e->setArgument(11); } if (v13_UserDefinedPropertySource) { e->setArgument(12,(*v13_UserDefinedPropertySource)); } else { e->setArgument(12); } e->setArgument(13,v14_ThermalLoadType,IfcThermalLoadTypeEnum::ToString(v14_ThermalLoadType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpaceType -IfcSpaceTypeEnum::IfcSpaceTypeEnum IfcSpaceType::PredefinedType() const { return IfcSpaceTypeEnum::FromString(*entity->getArgument(9)); } -void IfcSpaceType::setPredefinedType(IfcSpaceTypeEnum::IfcSpaceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcSpaceTypeEnum::ToString(v)); } -bool IfcSpaceType::is(Type::Enum v) const { return v == Type::IfcSpaceType || IfcSpatialStructureElementType::is(v); } -Type::Enum IfcSpaceType::type() const { return Type::IfcSpaceType; } +IfcSpaceTypeEnum::IfcSpaceTypeEnum IfcSpaceType::PredefinedType() const { return IfcSpaceTypeEnum::FromString(*data_->getArgument(9)); } +void IfcSpaceType::setPredefinedType(IfcSpaceTypeEnum::IfcSpaceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcSpaceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSpaceType::declaration() const { return *IfcSpaceType_type; } Type::Enum IfcSpaceType::Class() { return Type::IfcSpaceType; } -IfcSpaceType::IfcSpaceType(IfcAbstractEntity* e) : IfcSpatialStructureElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpaceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpaceType::IfcSpaceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSpaceTypeEnum::IfcSpaceTypeEnum v10_PredefinedType) : IfcSpatialStructureElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSpaceTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcSpaceType::IfcSpaceType(IfcAbstractEntity* e) : IfcSpatialStructureElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpaceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpaceType::IfcSpaceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSpaceTypeEnum::IfcSpaceTypeEnum v10_PredefinedType) : IfcSpatialStructureElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSpaceTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpatialStructureElement -bool IfcSpatialStructureElement::hasLongName() const { return !entity->getArgument(7)->isNull(); } -std::string IfcSpatialStructureElement::LongName() const { return *entity->getArgument(7); } -void IfcSpatialStructureElement::setLongName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcElementCompositionEnum::IfcElementCompositionEnum IfcSpatialStructureElement::CompositionType() const { return IfcElementCompositionEnum::FromString(*entity->getArgument(8)); } -void IfcSpatialStructureElement::setCompositionType(IfcElementCompositionEnum::IfcElementCompositionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcElementCompositionEnum::ToString(v)); } -IfcRelReferencedInSpatialStructure::list::ptr IfcSpatialStructureElement::ReferencesElements() const { return entity->getInverse(Type::IfcRelReferencedInSpatialStructure, 5)->as(); } -IfcRelServicesBuildings::list::ptr IfcSpatialStructureElement::ServicedBySystems() const { return entity->getInverse(Type::IfcRelServicesBuildings, 5)->as(); } -IfcRelContainedInSpatialStructure::list::ptr IfcSpatialStructureElement::ContainsElements() const { return entity->getInverse(Type::IfcRelContainedInSpatialStructure, 5)->as(); } -bool IfcSpatialStructureElement::is(Type::Enum v) const { return v == Type::IfcSpatialStructureElement || IfcProduct::is(v); } -Type::Enum IfcSpatialStructureElement::type() const { return Type::IfcSpatialStructureElement; } +bool IfcSpatialStructureElement::hasLongName() const { return !data_->getArgument(7)->isNull(); } +std::string IfcSpatialStructureElement::LongName() const { return *data_->getArgument(7); } +void IfcSpatialStructureElement::setLongName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +IfcElementCompositionEnum::IfcElementCompositionEnum IfcSpatialStructureElement::CompositionType() const { return IfcElementCompositionEnum::FromString(*data_->getArgument(8)); } +void IfcSpatialStructureElement::setCompositionType(IfcElementCompositionEnum::IfcElementCompositionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcElementCompositionEnum::ToString(v)); } + +IfcRelReferencedInSpatialStructure::list::ptr IfcSpatialStructureElement::ReferencesElements() const { return data_->getInverse(Type::IfcRelReferencedInSpatialStructure, 5)->as(); } +IfcRelServicesBuildings::list::ptr IfcSpatialStructureElement::ServicedBySystems() const { return data_->getInverse(Type::IfcRelServicesBuildings, 5)->as(); } +IfcRelContainedInSpatialStructure::list::ptr IfcSpatialStructureElement::ContainsElements() const { return data_->getInverse(Type::IfcRelContainedInSpatialStructure, 5)->as(); } + +const IfcParse::entity& IfcSpatialStructureElement::declaration() const { return *IfcSpatialStructureElement_type; } Type::Enum IfcSpatialStructureElement::Class() { return Type::IfcSpatialStructureElement; } -IfcSpatialStructureElement::IfcSpatialStructureElement(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialStructureElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpatialStructureElement::IfcSpatialStructureElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_LongName) { e->setArgument(7,(*v8_LongName)); } else { e->setArgument(7); } e->setArgument(8,v9_CompositionType,IfcElementCompositionEnum::ToString(v9_CompositionType)); entity = e; EntityBuffer::Add(this); } +IfcSpatialStructureElement::IfcSpatialStructureElement(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialStructureElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpatialStructureElement::IfcSpatialStructureElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_LongName) { e->setArgument(7,(*v8_LongName)); } else { e->setArgument(7); } e->setArgument(8,v9_CompositionType,IfcElementCompositionEnum::ToString(v9_CompositionType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpatialStructureElementType -bool IfcSpatialStructureElementType::is(Type::Enum v) const { return v == Type::IfcSpatialStructureElementType || IfcElementType::is(v); } -Type::Enum IfcSpatialStructureElementType::type() const { return Type::IfcSpatialStructureElementType; } + + +const IfcParse::entity& IfcSpatialStructureElementType::declaration() const { return *IfcSpatialStructureElementType_type; } Type::Enum IfcSpatialStructureElementType::Class() { return Type::IfcSpatialStructureElementType; } -IfcSpatialStructureElementType::IfcSpatialStructureElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialStructureElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpatialStructureElementType::IfcSpatialStructureElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSpatialStructureElementType::IfcSpatialStructureElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialStructureElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpatialStructureElementType::IfcSpatialStructureElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSphere -double IfcSphere::Radius() const { return *entity->getArgument(1); } -void IfcSphere::setRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcSphere::is(Type::Enum v) const { return v == Type::IfcSphere || IfcCsgPrimitive3D::is(v); } -Type::Enum IfcSphere::type() const { return Type::IfcSphere; } +double IfcSphere::Radius() const { return *data_->getArgument(1); } +void IfcSphere::setRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcSphere::declaration() const { return *IfcSphere_type; } Type::Enum IfcSphere::Class() { return Type::IfcSphere; } -IfcSphere::IfcSphere(IfcAbstractEntity* e) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSphere)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSphere::IfcSphere(IfcAxis2Placement3D* v1_Position, double v2_Radius) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_Radius)); entity = e; EntityBuffer::Add(this); } +IfcSphere::IfcSphere(IfcAbstractEntity* e) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSphere)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSphere::IfcSphere(IfcAxis2Placement3D* v1_Position, double v2_Radius) : IfcCsgPrimitive3D((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_Radius)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStackTerminalType -IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum IfcStackTerminalType::PredefinedType() const { return IfcStackTerminalTypeEnum::FromString(*entity->getArgument(9)); } -void IfcStackTerminalType::setPredefinedType(IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcStackTerminalTypeEnum::ToString(v)); } -bool IfcStackTerminalType::is(Type::Enum v) const { return v == Type::IfcStackTerminalType || IfcFlowTerminalType::is(v); } -Type::Enum IfcStackTerminalType::type() const { return Type::IfcStackTerminalType; } +IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum IfcStackTerminalType::PredefinedType() const { return IfcStackTerminalTypeEnum::FromString(*data_->getArgument(9)); } +void IfcStackTerminalType::setPredefinedType(IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcStackTerminalTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcStackTerminalType::declaration() const { return *IfcStackTerminalType_type; } Type::Enum IfcStackTerminalType::Class() { return Type::IfcStackTerminalType; } -IfcStackTerminalType::IfcStackTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStackTerminalType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStackTerminalType::IfcStackTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcStackTerminalTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcStackTerminalType::IfcStackTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStackTerminalType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStackTerminalType::IfcStackTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcStackTerminalTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStair -IfcStairTypeEnum::IfcStairTypeEnum IfcStair::ShapeType() const { return IfcStairTypeEnum::FromString(*entity->getArgument(8)); } -void IfcStair::setShapeType(IfcStairTypeEnum::IfcStairTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcStairTypeEnum::ToString(v)); } -bool IfcStair::is(Type::Enum v) const { return v == Type::IfcStair || IfcBuildingElement::is(v); } -Type::Enum IfcStair::type() const { return Type::IfcStair; } +IfcStairTypeEnum::IfcStairTypeEnum IfcStair::ShapeType() const { return IfcStairTypeEnum::FromString(*data_->getArgument(8)); } +void IfcStair::setShapeType(IfcStairTypeEnum::IfcStairTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcStairTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcStair::declaration() const { return *IfcStair_type; } Type::Enum IfcStair::Class() { return Type::IfcStair; } -IfcStair::IfcStair(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStair)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStair::IfcStair(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcStairTypeEnum::IfcStairTypeEnum v9_ShapeType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_ShapeType,IfcStairTypeEnum::ToString(v9_ShapeType)); entity = e; EntityBuffer::Add(this); } +IfcStair::IfcStair(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStair)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStair::IfcStair(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcStairTypeEnum::IfcStairTypeEnum v9_ShapeType) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_ShapeType,IfcStairTypeEnum::ToString(v9_ShapeType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStairFlight -bool IfcStairFlight::hasNumberOfRiser() const { return !entity->getArgument(8)->isNull(); } -int IfcStairFlight::NumberOfRiser() const { return *entity->getArgument(8); } -void IfcStairFlight::setNumberOfRiser(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcStairFlight::hasNumberOfTreads() const { return !entity->getArgument(9)->isNull(); } -int IfcStairFlight::NumberOfTreads() const { return *entity->getArgument(9); } -void IfcStairFlight::setNumberOfTreads(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcStairFlight::hasRiserHeight() const { return !entity->getArgument(10)->isNull(); } -double IfcStairFlight::RiserHeight() const { return *entity->getArgument(10); } -void IfcStairFlight::setRiserHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcStairFlight::hasTreadLength() const { return !entity->getArgument(11)->isNull(); } -double IfcStairFlight::TreadLength() const { return *entity->getArgument(11); } -void IfcStairFlight::setTreadLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcStairFlight::is(Type::Enum v) const { return v == Type::IfcStairFlight || IfcBuildingElement::is(v); } -Type::Enum IfcStairFlight::type() const { return Type::IfcStairFlight; } +bool IfcStairFlight::hasNumberOfRiser() const { return !data_->getArgument(8)->isNull(); } +int IfcStairFlight::NumberOfRiser() const { return *data_->getArgument(8); } +void IfcStairFlight::setNumberOfRiser(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcStairFlight::hasNumberOfTreads() const { return !data_->getArgument(9)->isNull(); } +int IfcStairFlight::NumberOfTreads() const { return *data_->getArgument(9); } +void IfcStairFlight::setNumberOfTreads(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcStairFlight::hasRiserHeight() const { return !data_->getArgument(10)->isNull(); } +double IfcStairFlight::RiserHeight() const { return *data_->getArgument(10); } +void IfcStairFlight::setRiserHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcStairFlight::hasTreadLength() const { return !data_->getArgument(11)->isNull(); } +double IfcStairFlight::TreadLength() const { return *data_->getArgument(11); } +void IfcStairFlight::setTreadLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } + + +const IfcParse::entity& IfcStairFlight::declaration() const { return *IfcStairFlight_type; } Type::Enum IfcStairFlight::Class() { return Type::IfcStairFlight; } -IfcStairFlight::IfcStairFlight(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStairFlight)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStairFlight::IfcStairFlight(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< int > v9_NumberOfRiser, boost::optional< int > v10_NumberOfTreads, boost::optional< double > v11_RiserHeight, boost::optional< double > v12_TreadLength) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_NumberOfRiser) { e->setArgument(8,(*v9_NumberOfRiser)); } else { e->setArgument(8); } if (v10_NumberOfTreads) { e->setArgument(9,(*v10_NumberOfTreads)); } else { e->setArgument(9); } if (v11_RiserHeight) { e->setArgument(10,(*v11_RiserHeight)); } else { e->setArgument(10); } if (v12_TreadLength) { e->setArgument(11,(*v12_TreadLength)); } else { e->setArgument(11); } entity = e; EntityBuffer::Add(this); } +IfcStairFlight::IfcStairFlight(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStairFlight)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStairFlight::IfcStairFlight(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< int > v9_NumberOfRiser, boost::optional< int > v10_NumberOfTreads, boost::optional< double > v11_RiserHeight, boost::optional< double > v12_TreadLength) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_NumberOfRiser) { e->setArgument(8,(*v9_NumberOfRiser)); } else { e->setArgument(8); } if (v10_NumberOfTreads) { e->setArgument(9,(*v10_NumberOfTreads)); } else { e->setArgument(9); } if (v11_RiserHeight) { e->setArgument(10,(*v11_RiserHeight)); } else { e->setArgument(10); } if (v12_TreadLength) { e->setArgument(11,(*v12_TreadLength)); } else { e->setArgument(11); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStairFlightType -IfcStairFlightTypeEnum::IfcStairFlightTypeEnum IfcStairFlightType::PredefinedType() const { return IfcStairFlightTypeEnum::FromString(*entity->getArgument(9)); } -void IfcStairFlightType::setPredefinedType(IfcStairFlightTypeEnum::IfcStairFlightTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcStairFlightTypeEnum::ToString(v)); } -bool IfcStairFlightType::is(Type::Enum v) const { return v == Type::IfcStairFlightType || IfcBuildingElementType::is(v); } -Type::Enum IfcStairFlightType::type() const { return Type::IfcStairFlightType; } +IfcStairFlightTypeEnum::IfcStairFlightTypeEnum IfcStairFlightType::PredefinedType() const { return IfcStairFlightTypeEnum::FromString(*data_->getArgument(9)); } +void IfcStairFlightType::setPredefinedType(IfcStairFlightTypeEnum::IfcStairFlightTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcStairFlightTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcStairFlightType::declaration() const { return *IfcStairFlightType_type; } Type::Enum IfcStairFlightType::Class() { return Type::IfcStairFlightType; } -IfcStairFlightType::IfcStairFlightType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStairFlightType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStairFlightType::IfcStairFlightType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcStairFlightTypeEnum::IfcStairFlightTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcStairFlightTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcStairFlightType::IfcStairFlightType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStairFlightType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStairFlightType::IfcStairFlightType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcStairFlightTypeEnum::IfcStairFlightTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcStairFlightTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralAction -bool IfcStructuralAction::DestabilizingLoad() const { return *entity->getArgument(9); } -void IfcStructuralAction::setDestabilizingLoad(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcStructuralAction::hasCausedBy() const { return !entity->getArgument(10)->isNull(); } -IfcStructuralReaction* IfcStructuralAction::CausedBy() const { return (IfcStructuralReaction*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcStructuralAction::setCausedBy(IfcStructuralReaction* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcStructuralAction::is(Type::Enum v) const { return v == Type::IfcStructuralAction || IfcStructuralActivity::is(v); } -Type::Enum IfcStructuralAction::type() const { return Type::IfcStructuralAction; } +bool IfcStructuralAction::DestabilizingLoad() const { return *data_->getArgument(9); } +void IfcStructuralAction::setDestabilizingLoad(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcStructuralAction::hasCausedBy() const { return !data_->getArgument(10)->isNull(); } +IfcStructuralReaction* IfcStructuralAction::CausedBy() const { return (IfcStructuralReaction*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcStructuralAction::setCausedBy(IfcStructuralReaction* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcStructuralAction::declaration() const { return *IfcStructuralAction_type; } Type::Enum IfcStructuralAction::Class() { return Type::IfcStructuralAction; } -IfcStructuralAction::IfcStructuralAction(IfcAbstractEntity* e) : IfcStructuralActivity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralAction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralAction::IfcStructuralAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy) : IfcStructuralActivity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); entity = e; EntityBuffer::Add(this); } +IfcStructuralAction::IfcStructuralAction(IfcAbstractEntity* e) : IfcStructuralActivity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralAction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralAction::IfcStructuralAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy) : IfcStructuralActivity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralActivity -IfcStructuralLoad* IfcStructuralActivity::AppliedLoad() const { return (IfcStructuralLoad*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcStructuralActivity::setAppliedLoad(IfcStructuralLoad* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum IfcStructuralActivity::GlobalOrLocal() const { return IfcGlobalOrLocalEnum::FromString(*entity->getArgument(8)); } -void IfcStructuralActivity::setGlobalOrLocal(IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcGlobalOrLocalEnum::ToString(v)); } -IfcRelConnectsStructuralActivity::list::ptr IfcStructuralActivity::AssignedToStructuralItem() const { return entity->getInverse(Type::IfcRelConnectsStructuralActivity, 5)->as(); } -bool IfcStructuralActivity::is(Type::Enum v) const { return v == Type::IfcStructuralActivity || IfcProduct::is(v); } -Type::Enum IfcStructuralActivity::type() const { return Type::IfcStructuralActivity; } +IfcStructuralLoad* IfcStructuralActivity::AppliedLoad() const { return (IfcStructuralLoad*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcStructuralActivity::setAppliedLoad(IfcStructuralLoad* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum IfcStructuralActivity::GlobalOrLocal() const { return IfcGlobalOrLocalEnum::FromString(*data_->getArgument(8)); } +void IfcStructuralActivity::setGlobalOrLocal(IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcGlobalOrLocalEnum::ToString(v)); } + +IfcRelConnectsStructuralActivity::list::ptr IfcStructuralActivity::AssignedToStructuralItem() const { return data_->getInverse(Type::IfcRelConnectsStructuralActivity, 5)->as(); } + +const IfcParse::entity& IfcStructuralActivity::declaration() const { return *IfcStructuralActivity_type; } Type::Enum IfcStructuralActivity::Class() { return Type::IfcStructuralActivity; } -IfcStructuralActivity::IfcStructuralActivity(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralActivity)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralActivity::IfcStructuralActivity(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); entity = e; EntityBuffer::Add(this); } +IfcStructuralActivity::IfcStructuralActivity(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralActivity)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralActivity::IfcStructuralActivity(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralAnalysisModel -IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum IfcStructuralAnalysisModel::PredefinedType() const { return IfcAnalysisModelTypeEnum::FromString(*entity->getArgument(5)); } -void IfcStructuralAnalysisModel::setPredefinedType(IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcAnalysisModelTypeEnum::ToString(v)); } -bool IfcStructuralAnalysisModel::hasOrientationOf2DPlane() const { return !entity->getArgument(6)->isNull(); } -IfcAxis2Placement3D* IfcStructuralAnalysisModel::OrientationOf2DPlane() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcStructuralAnalysisModel::setOrientationOf2DPlane(IfcAxis2Placement3D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcStructuralAnalysisModel::hasLoadedBy() const { return !entity->getArgument(7)->isNull(); } -IfcTemplatedEntityList< IfcStructuralLoadGroup >::ptr IfcStructuralAnalysisModel::LoadedBy() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcStructuralAnalysisModel::setLoadedBy(IfcTemplatedEntityList< IfcStructuralLoadGroup >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -bool IfcStructuralAnalysisModel::hasHasResults() const { return !entity->getArgument(8)->isNull(); } -IfcTemplatedEntityList< IfcStructuralResultGroup >::ptr IfcStructuralAnalysisModel::HasResults() const { IfcEntityList::ptr es = *entity->getArgument(8); return es->as(); } -void IfcStructuralAnalysisModel::setHasResults(IfcTemplatedEntityList< IfcStructuralResultGroup >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v->generalize()); } -bool IfcStructuralAnalysisModel::is(Type::Enum v) const { return v == Type::IfcStructuralAnalysisModel || IfcSystem::is(v); } -Type::Enum IfcStructuralAnalysisModel::type() const { return Type::IfcStructuralAnalysisModel; } +IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum IfcStructuralAnalysisModel::PredefinedType() const { return IfcAnalysisModelTypeEnum::FromString(*data_->getArgument(5)); } +void IfcStructuralAnalysisModel::setPredefinedType(IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcAnalysisModelTypeEnum::ToString(v)); } +bool IfcStructuralAnalysisModel::hasOrientationOf2DPlane() const { return !data_->getArgument(6)->isNull(); } +IfcAxis2Placement3D* IfcStructuralAnalysisModel::OrientationOf2DPlane() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcStructuralAnalysisModel::setOrientationOf2DPlane(IfcAxis2Placement3D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcStructuralAnalysisModel::hasLoadedBy() const { return !data_->getArgument(7)->isNull(); } +IfcTemplatedEntityList< IfcStructuralLoadGroup >::ptr IfcStructuralAnalysisModel::LoadedBy() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcStructuralAnalysisModel::setLoadedBy(IfcTemplatedEntityList< IfcStructuralLoadGroup >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } +bool IfcStructuralAnalysisModel::hasHasResults() const { return !data_->getArgument(8)->isNull(); } +IfcTemplatedEntityList< IfcStructuralResultGroup >::ptr IfcStructuralAnalysisModel::HasResults() const { IfcEntityList::ptr es = *data_->getArgument(8); return es->as(); } +void IfcStructuralAnalysisModel::setHasResults(IfcTemplatedEntityList< IfcStructuralResultGroup >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v->generalize()); } + + +const IfcParse::entity& IfcStructuralAnalysisModel::declaration() const { return *IfcStructuralAnalysisModel_type; } Type::Enum IfcStructuralAnalysisModel::Class() { return Type::IfcStructuralAnalysisModel; } -IfcStructuralAnalysisModel::IfcStructuralAnalysisModel(IfcAbstractEntity* e) : IfcSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralAnalysisModel)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralAnalysisModel::IfcStructuralAnalysisModel(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum v6_PredefinedType, IfcAxis2Placement3D* v7_OrientationOf2DPlane, boost::optional< IfcTemplatedEntityList< IfcStructuralLoadGroup >::ptr > v8_LoadedBy, boost::optional< IfcTemplatedEntityList< IfcStructuralResultGroup >::ptr > v9_HasResults) : IfcSystem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,v6_PredefinedType,IfcAnalysisModelTypeEnum::ToString(v6_PredefinedType)); e->setArgument(6,(v7_OrientationOf2DPlane)); if (v8_LoadedBy) { e->setArgument(7,(*v8_LoadedBy)->generalize()); } else { e->setArgument(7); } if (v9_HasResults) { e->setArgument(8,(*v9_HasResults)->generalize()); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcStructuralAnalysisModel::IfcStructuralAnalysisModel(IfcAbstractEntity* e) : IfcSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralAnalysisModel)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralAnalysisModel::IfcStructuralAnalysisModel(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum v6_PredefinedType, IfcAxis2Placement3D* v7_OrientationOf2DPlane, boost::optional< IfcTemplatedEntityList< IfcStructuralLoadGroup >::ptr > v8_LoadedBy, boost::optional< IfcTemplatedEntityList< IfcStructuralResultGroup >::ptr > v9_HasResults) : IfcSystem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,v6_PredefinedType,IfcAnalysisModelTypeEnum::ToString(v6_PredefinedType)); e->setArgument(6,(v7_OrientationOf2DPlane)); if (v8_LoadedBy) { e->setArgument(7,(*v8_LoadedBy)->generalize()); } else { e->setArgument(7); } if (v9_HasResults) { e->setArgument(8,(*v9_HasResults)->generalize()); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralConnection -bool IfcStructuralConnection::hasAppliedCondition() const { return !entity->getArgument(7)->isNull(); } -IfcBoundaryCondition* IfcStructuralConnection::AppliedCondition() const { return (IfcBoundaryCondition*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcStructuralConnection::setAppliedCondition(IfcBoundaryCondition* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcRelConnectsStructuralMember::list::ptr IfcStructuralConnection::ConnectsStructuralMembers() const { return entity->getInverse(Type::IfcRelConnectsStructuralMember, 5)->as(); } -bool IfcStructuralConnection::is(Type::Enum v) const { return v == Type::IfcStructuralConnection || IfcStructuralItem::is(v); } -Type::Enum IfcStructuralConnection::type() const { return Type::IfcStructuralConnection; } +bool IfcStructuralConnection::hasAppliedCondition() const { return !data_->getArgument(7)->isNull(); } +IfcBoundaryCondition* IfcStructuralConnection::AppliedCondition() const { return (IfcBoundaryCondition*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcStructuralConnection::setAppliedCondition(IfcBoundaryCondition* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + +IfcRelConnectsStructuralMember::list::ptr IfcStructuralConnection::ConnectsStructuralMembers() const { return data_->getInverse(Type::IfcRelConnectsStructuralMember, 5)->as(); } + +const IfcParse::entity& IfcStructuralConnection::declaration() const { return *IfcStructuralConnection_type; } Type::Enum IfcStructuralConnection::Class() { return Type::IfcStructuralConnection; } -IfcStructuralConnection::IfcStructuralConnection(IfcAbstractEntity* e) : IfcStructuralItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralConnection)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralConnection::IfcStructuralConnection(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedCondition)); entity = e; EntityBuffer::Add(this); } +IfcStructuralConnection::IfcStructuralConnection(IfcAbstractEntity* e) : IfcStructuralItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralConnection)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralConnection::IfcStructuralConnection(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedCondition)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralConnectionCondition -bool IfcStructuralConnectionCondition::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcStructuralConnectionCondition::Name() const { return *entity->getArgument(0); } -void IfcStructuralConnectionCondition::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcStructuralConnectionCondition::is(Type::Enum v) const { return v == Type::IfcStructuralConnectionCondition; } -Type::Enum IfcStructuralConnectionCondition::type() const { return Type::IfcStructuralConnectionCondition; } +bool IfcStructuralConnectionCondition::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcStructuralConnectionCondition::Name() const { return *data_->getArgument(0); } +void IfcStructuralConnectionCondition::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcStructuralConnectionCondition::declaration() const { return *IfcStructuralConnectionCondition_type; } Type::Enum IfcStructuralConnectionCondition::Class() { return Type::IfcStructuralConnectionCondition; } -IfcStructuralConnectionCondition::IfcStructuralConnectionCondition(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcStructuralConnectionCondition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralConnectionCondition::IfcStructuralConnectionCondition(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } entity = e; EntityBuffer::Add(this); } +IfcStructuralConnectionCondition::IfcStructuralConnectionCondition(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcStructuralConnectionCondition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralConnectionCondition::IfcStructuralConnectionCondition(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralCurveConnection -bool IfcStructuralCurveConnection::is(Type::Enum v) const { return v == Type::IfcStructuralCurveConnection || IfcStructuralConnection::is(v); } -Type::Enum IfcStructuralCurveConnection::type() const { return Type::IfcStructuralCurveConnection; } + + +const IfcParse::entity& IfcStructuralCurveConnection::declaration() const { return *IfcStructuralCurveConnection_type; } Type::Enum IfcStructuralCurveConnection::Class() { return Type::IfcStructuralCurveConnection; } -IfcStructuralCurveConnection::IfcStructuralCurveConnection(IfcAbstractEntity* e) : IfcStructuralConnection((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralCurveConnection)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralCurveConnection::IfcStructuralCurveConnection(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralConnection((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedCondition)); entity = e; EntityBuffer::Add(this); } +IfcStructuralCurveConnection::IfcStructuralCurveConnection(IfcAbstractEntity* e) : IfcStructuralConnection((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralCurveConnection)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralCurveConnection::IfcStructuralCurveConnection(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralConnection((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedCondition)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralCurveMember -IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum IfcStructuralCurveMember::PredefinedType() const { return IfcStructuralCurveTypeEnum::FromString(*entity->getArgument(7)); } -void IfcStructuralCurveMember::setPredefinedType(IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcStructuralCurveTypeEnum::ToString(v)); } -bool IfcStructuralCurveMember::is(Type::Enum v) const { return v == Type::IfcStructuralCurveMember || IfcStructuralMember::is(v); } -Type::Enum IfcStructuralCurveMember::type() const { return Type::IfcStructuralCurveMember; } +IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum IfcStructuralCurveMember::PredefinedType() const { return IfcStructuralCurveTypeEnum::FromString(*data_->getArgument(7)); } +void IfcStructuralCurveMember::setPredefinedType(IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcStructuralCurveTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcStructuralCurveMember::declaration() const { return *IfcStructuralCurveMember_type; } Type::Enum IfcStructuralCurveMember::Class() { return Type::IfcStructuralCurveMember; } -IfcStructuralCurveMember::IfcStructuralCurveMember(IfcAbstractEntity* e) : IfcStructuralMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralCurveMember)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralCurveMember::IfcStructuralCurveMember(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum v8_PredefinedType) : IfcStructuralMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,v8_PredefinedType,IfcStructuralCurveTypeEnum::ToString(v8_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcStructuralCurveMember::IfcStructuralCurveMember(IfcAbstractEntity* e) : IfcStructuralMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralCurveMember)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralCurveMember::IfcStructuralCurveMember(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum v8_PredefinedType) : IfcStructuralMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,v8_PredefinedType,IfcStructuralCurveTypeEnum::ToString(v8_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralCurveMemberVarying -bool IfcStructuralCurveMemberVarying::is(Type::Enum v) const { return v == Type::IfcStructuralCurveMemberVarying || IfcStructuralCurveMember::is(v); } -Type::Enum IfcStructuralCurveMemberVarying::type() const { return Type::IfcStructuralCurveMemberVarying; } + + +const IfcParse::entity& IfcStructuralCurveMemberVarying::declaration() const { return *IfcStructuralCurveMemberVarying_type; } Type::Enum IfcStructuralCurveMemberVarying::Class() { return Type::IfcStructuralCurveMemberVarying; } -IfcStructuralCurveMemberVarying::IfcStructuralCurveMemberVarying(IfcAbstractEntity* e) : IfcStructuralCurveMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralCurveMemberVarying)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralCurveMemberVarying::IfcStructuralCurveMemberVarying(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum v8_PredefinedType) : IfcStructuralCurveMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,v8_PredefinedType,IfcStructuralCurveTypeEnum::ToString(v8_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcStructuralCurveMemberVarying::IfcStructuralCurveMemberVarying(IfcAbstractEntity* e) : IfcStructuralCurveMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralCurveMemberVarying)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralCurveMemberVarying::IfcStructuralCurveMemberVarying(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum v8_PredefinedType) : IfcStructuralCurveMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,v8_PredefinedType,IfcStructuralCurveTypeEnum::ToString(v8_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralItem -IfcRelConnectsStructuralActivity::list::ptr IfcStructuralItem::AssignedStructuralActivity() const { return entity->getInverse(Type::IfcRelConnectsStructuralActivity, 4)->as(); } -bool IfcStructuralItem::is(Type::Enum v) const { return v == Type::IfcStructuralItem || IfcProduct::is(v); } -Type::Enum IfcStructuralItem::type() const { return Type::IfcStructuralItem; } + +IfcRelConnectsStructuralActivity::list::ptr IfcStructuralItem::AssignedStructuralActivity() const { return data_->getInverse(Type::IfcRelConnectsStructuralActivity, 4)->as(); } + +const IfcParse::entity& IfcStructuralItem::declaration() const { return *IfcStructuralItem_type; } Type::Enum IfcStructuralItem::Class() { return Type::IfcStructuralItem; } -IfcStructuralItem::IfcStructuralItem(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralItem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralItem::IfcStructuralItem(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); entity = e; EntityBuffer::Add(this); } +IfcStructuralItem::IfcStructuralItem(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralItem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralItem::IfcStructuralItem(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation) : IfcProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLinearAction -IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralLinearAction::ProjectedOrTrue() const { return IfcProjectedOrTrueLengthEnum::FromString(*entity->getArgument(11)); } -void IfcStructuralLinearAction::setProjectedOrTrue(IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcProjectedOrTrueLengthEnum::ToString(v)); } -bool IfcStructuralLinearAction::is(Type::Enum v) const { return v == Type::IfcStructuralLinearAction || IfcStructuralAction::is(v); } -Type::Enum IfcStructuralLinearAction::type() const { return Type::IfcStructuralLinearAction; } +IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralLinearAction::ProjectedOrTrue() const { return IfcProjectedOrTrueLengthEnum::FromString(*data_->getArgument(11)); } +void IfcStructuralLinearAction::setProjectedOrTrue(IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcProjectedOrTrueLengthEnum::ToString(v)); } + + +const IfcParse::entity& IfcStructuralLinearAction::declaration() const { return *IfcStructuralLinearAction_type; } Type::Enum IfcStructuralLinearAction::Class() { return Type::IfcStructuralLinearAction; } -IfcStructuralLinearAction::IfcStructuralLinearAction(IfcAbstractEntity* e) : IfcStructuralAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLinearAction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLinearAction::IfcStructuralLinearAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue) : IfcStructuralAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); e->setArgument(11,v12_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(v12_ProjectedOrTrue)); entity = e; EntityBuffer::Add(this); } +IfcStructuralLinearAction::IfcStructuralLinearAction(IfcAbstractEntity* e) : IfcStructuralAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLinearAction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLinearAction::IfcStructuralLinearAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue) : IfcStructuralAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); e->setArgument(11,v12_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(v12_ProjectedOrTrue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLinearActionVarying -IfcShapeAspect* IfcStructuralLinearActionVarying::VaryingAppliedLoadLocation() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(12))); } -void IfcStructuralLinearActionVarying::setVaryingAppliedLoadLocation(IfcShapeAspect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -IfcTemplatedEntityList< IfcStructuralLoad >::ptr IfcStructuralLinearActionVarying::SubsequentAppliedLoads() const { IfcEntityList::ptr es = *entity->getArgument(13); return es->as(); } -void IfcStructuralLinearActionVarying::setSubsequentAppliedLoads(IfcTemplatedEntityList< IfcStructuralLoad >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v->generalize()); } -bool IfcStructuralLinearActionVarying::is(Type::Enum v) const { return v == Type::IfcStructuralLinearActionVarying || IfcStructuralLinearAction::is(v); } -Type::Enum IfcStructuralLinearActionVarying::type() const { return Type::IfcStructuralLinearActionVarying; } +IfcShapeAspect* IfcStructuralLinearActionVarying::VaryingAppliedLoadLocation() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(12))); } +void IfcStructuralLinearActionVarying::setVaryingAppliedLoadLocation(IfcShapeAspect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +IfcTemplatedEntityList< IfcStructuralLoad >::ptr IfcStructuralLinearActionVarying::SubsequentAppliedLoads() const { IfcEntityList::ptr es = *data_->getArgument(13); return es->as(); } +void IfcStructuralLinearActionVarying::setSubsequentAppliedLoads(IfcTemplatedEntityList< IfcStructuralLoad >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v->generalize()); } + + +const IfcParse::entity& IfcStructuralLinearActionVarying::declaration() const { return *IfcStructuralLinearActionVarying_type; } Type::Enum IfcStructuralLinearActionVarying::Class() { return Type::IfcStructuralLinearActionVarying; } -IfcStructuralLinearActionVarying::IfcStructuralLinearActionVarying(IfcAbstractEntity* e) : IfcStructuralLinearAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLinearActionVarying)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLinearActionVarying::IfcStructuralLinearActionVarying(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue, IfcShapeAspect* v13_VaryingAppliedLoadLocation, IfcTemplatedEntityList< IfcStructuralLoad >::ptr v14_SubsequentAppliedLoads) : IfcStructuralLinearAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); e->setArgument(11,v12_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(v12_ProjectedOrTrue)); e->setArgument(12,(v13_VaryingAppliedLoadLocation)); e->setArgument(13,(v14_SubsequentAppliedLoads)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcStructuralLinearActionVarying::IfcStructuralLinearActionVarying(IfcAbstractEntity* e) : IfcStructuralLinearAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLinearActionVarying)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLinearActionVarying::IfcStructuralLinearActionVarying(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue, IfcShapeAspect* v13_VaryingAppliedLoadLocation, IfcTemplatedEntityList< IfcStructuralLoad >::ptr v14_SubsequentAppliedLoads) : IfcStructuralLinearAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); e->setArgument(11,v12_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(v12_ProjectedOrTrue)); e->setArgument(12,(v13_VaryingAppliedLoadLocation)); e->setArgument(13,(v14_SubsequentAppliedLoads)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLoad -bool IfcStructuralLoad::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcStructuralLoad::Name() const { return *entity->getArgument(0); } -void IfcStructuralLoad::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcStructuralLoad::is(Type::Enum v) const { return v == Type::IfcStructuralLoad; } -Type::Enum IfcStructuralLoad::type() const { return Type::IfcStructuralLoad; } +bool IfcStructuralLoad::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcStructuralLoad::Name() const { return *data_->getArgument(0); } +void IfcStructuralLoad::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcStructuralLoad::declaration() const { return *IfcStructuralLoad_type; } Type::Enum IfcStructuralLoad::Class() { return Type::IfcStructuralLoad; } -IfcStructuralLoad::IfcStructuralLoad(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcStructuralLoad)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoad::IfcStructuralLoad(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoad::IfcStructuralLoad(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcStructuralLoad)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoad::IfcStructuralLoad(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLoadGroup -IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum IfcStructuralLoadGroup::PredefinedType() const { return IfcLoadGroupTypeEnum::FromString(*entity->getArgument(5)); } -void IfcStructuralLoadGroup::setPredefinedType(IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcLoadGroupTypeEnum::ToString(v)); } -IfcActionTypeEnum::IfcActionTypeEnum IfcStructuralLoadGroup::ActionType() const { return IfcActionTypeEnum::FromString(*entity->getArgument(6)); } -void IfcStructuralLoadGroup::setActionType(IfcActionTypeEnum::IfcActionTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcActionTypeEnum::ToString(v)); } -IfcActionSourceTypeEnum::IfcActionSourceTypeEnum IfcStructuralLoadGroup::ActionSource() const { return IfcActionSourceTypeEnum::FromString(*entity->getArgument(7)); } -void IfcStructuralLoadGroup::setActionSource(IfcActionSourceTypeEnum::IfcActionSourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcActionSourceTypeEnum::ToString(v)); } -bool IfcStructuralLoadGroup::hasCoefficient() const { return !entity->getArgument(8)->isNull(); } -double IfcStructuralLoadGroup::Coefficient() const { return *entity->getArgument(8); } -void IfcStructuralLoadGroup::setCoefficient(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcStructuralLoadGroup::hasPurpose() const { return !entity->getArgument(9)->isNull(); } -std::string IfcStructuralLoadGroup::Purpose() const { return *entity->getArgument(9); } -void IfcStructuralLoadGroup::setPurpose(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -IfcStructuralResultGroup::list::ptr IfcStructuralLoadGroup::SourceOfResultGroup() const { return entity->getInverse(Type::IfcStructuralResultGroup, 6)->as(); } -IfcStructuralAnalysisModel::list::ptr IfcStructuralLoadGroup::LoadGroupFor() const { return entity->getInverse(Type::IfcStructuralAnalysisModel, 7)->as(); } -bool IfcStructuralLoadGroup::is(Type::Enum v) const { return v == Type::IfcStructuralLoadGroup || IfcGroup::is(v); } -Type::Enum IfcStructuralLoadGroup::type() const { return Type::IfcStructuralLoadGroup; } +IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum IfcStructuralLoadGroup::PredefinedType() const { return IfcLoadGroupTypeEnum::FromString(*data_->getArgument(5)); } +void IfcStructuralLoadGroup::setPredefinedType(IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcLoadGroupTypeEnum::ToString(v)); } +IfcActionTypeEnum::IfcActionTypeEnum IfcStructuralLoadGroup::ActionType() const { return IfcActionTypeEnum::FromString(*data_->getArgument(6)); } +void IfcStructuralLoadGroup::setActionType(IfcActionTypeEnum::IfcActionTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcActionTypeEnum::ToString(v)); } +IfcActionSourceTypeEnum::IfcActionSourceTypeEnum IfcStructuralLoadGroup::ActionSource() const { return IfcActionSourceTypeEnum::FromString(*data_->getArgument(7)); } +void IfcStructuralLoadGroup::setActionSource(IfcActionSourceTypeEnum::IfcActionSourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcActionSourceTypeEnum::ToString(v)); } +bool IfcStructuralLoadGroup::hasCoefficient() const { return !data_->getArgument(8)->isNull(); } +double IfcStructuralLoadGroup::Coefficient() const { return *data_->getArgument(8); } +void IfcStructuralLoadGroup::setCoefficient(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcStructuralLoadGroup::hasPurpose() const { return !data_->getArgument(9)->isNull(); } +std::string IfcStructuralLoadGroup::Purpose() const { return *data_->getArgument(9); } +void IfcStructuralLoadGroup::setPurpose(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + +IfcStructuralResultGroup::list::ptr IfcStructuralLoadGroup::SourceOfResultGroup() const { return data_->getInverse(Type::IfcStructuralResultGroup, 6)->as(); } +IfcStructuralAnalysisModel::list::ptr IfcStructuralLoadGroup::LoadGroupFor() const { return data_->getInverse(Type::IfcStructuralAnalysisModel, 7)->as(); } + +const IfcParse::entity& IfcStructuralLoadGroup::declaration() const { return *IfcStructuralLoadGroup_type; } Type::Enum IfcStructuralLoadGroup::Class() { return Type::IfcStructuralLoadGroup; } -IfcStructuralLoadGroup::IfcStructuralLoadGroup(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadGroup)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadGroup::IfcStructuralLoadGroup(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum v6_PredefinedType, IfcActionTypeEnum::IfcActionTypeEnum v7_ActionType, IfcActionSourceTypeEnum::IfcActionSourceTypeEnum v8_ActionSource, boost::optional< double > v9_Coefficient, boost::optional< std::string > v10_Purpose) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,v6_PredefinedType,IfcLoadGroupTypeEnum::ToString(v6_PredefinedType)); e->setArgument(6,v7_ActionType,IfcActionTypeEnum::ToString(v7_ActionType)); e->setArgument(7,v8_ActionSource,IfcActionSourceTypeEnum::ToString(v8_ActionSource)); if (v9_Coefficient) { e->setArgument(8,(*v9_Coefficient)); } else { e->setArgument(8); } if (v10_Purpose) { e->setArgument(9,(*v10_Purpose)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoadGroup::IfcStructuralLoadGroup(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadGroup)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadGroup::IfcStructuralLoadGroup(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum v6_PredefinedType, IfcActionTypeEnum::IfcActionTypeEnum v7_ActionType, IfcActionSourceTypeEnum::IfcActionSourceTypeEnum v8_ActionSource, boost::optional< double > v9_Coefficient, boost::optional< std::string > v10_Purpose) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,v6_PredefinedType,IfcLoadGroupTypeEnum::ToString(v6_PredefinedType)); e->setArgument(6,v7_ActionType,IfcActionTypeEnum::ToString(v7_ActionType)); e->setArgument(7,v8_ActionSource,IfcActionSourceTypeEnum::ToString(v8_ActionSource)); if (v9_Coefficient) { e->setArgument(8,(*v9_Coefficient)); } else { e->setArgument(8); } if (v10_Purpose) { e->setArgument(9,(*v10_Purpose)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLoadLinearForce -bool IfcStructuralLoadLinearForce::hasLinearForceX() const { return !entity->getArgument(1)->isNull(); } -double IfcStructuralLoadLinearForce::LinearForceX() const { return *entity->getArgument(1); } -void IfcStructuralLoadLinearForce::setLinearForceX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcStructuralLoadLinearForce::hasLinearForceY() const { return !entity->getArgument(2)->isNull(); } -double IfcStructuralLoadLinearForce::LinearForceY() const { return *entity->getArgument(2); } -void IfcStructuralLoadLinearForce::setLinearForceY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcStructuralLoadLinearForce::hasLinearForceZ() const { return !entity->getArgument(3)->isNull(); } -double IfcStructuralLoadLinearForce::LinearForceZ() const { return *entity->getArgument(3); } -void IfcStructuralLoadLinearForce::setLinearForceZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcStructuralLoadLinearForce::hasLinearMomentX() const { return !entity->getArgument(4)->isNull(); } -double IfcStructuralLoadLinearForce::LinearMomentX() const { return *entity->getArgument(4); } -void IfcStructuralLoadLinearForce::setLinearMomentX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcStructuralLoadLinearForce::hasLinearMomentY() const { return !entity->getArgument(5)->isNull(); } -double IfcStructuralLoadLinearForce::LinearMomentY() const { return *entity->getArgument(5); } -void IfcStructuralLoadLinearForce::setLinearMomentY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcStructuralLoadLinearForce::hasLinearMomentZ() const { return !entity->getArgument(6)->isNull(); } -double IfcStructuralLoadLinearForce::LinearMomentZ() const { return *entity->getArgument(6); } -void IfcStructuralLoadLinearForce::setLinearMomentZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcStructuralLoadLinearForce::is(Type::Enum v) const { return v == Type::IfcStructuralLoadLinearForce || IfcStructuralLoadStatic::is(v); } -Type::Enum IfcStructuralLoadLinearForce::type() const { return Type::IfcStructuralLoadLinearForce; } +bool IfcStructuralLoadLinearForce::hasLinearForceX() const { return !data_->getArgument(1)->isNull(); } +double IfcStructuralLoadLinearForce::LinearForceX() const { return *data_->getArgument(1); } +void IfcStructuralLoadLinearForce::setLinearForceX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcStructuralLoadLinearForce::hasLinearForceY() const { return !data_->getArgument(2)->isNull(); } +double IfcStructuralLoadLinearForce::LinearForceY() const { return *data_->getArgument(2); } +void IfcStructuralLoadLinearForce::setLinearForceY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcStructuralLoadLinearForce::hasLinearForceZ() const { return !data_->getArgument(3)->isNull(); } +double IfcStructuralLoadLinearForce::LinearForceZ() const { return *data_->getArgument(3); } +void IfcStructuralLoadLinearForce::setLinearForceZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcStructuralLoadLinearForce::hasLinearMomentX() const { return !data_->getArgument(4)->isNull(); } +double IfcStructuralLoadLinearForce::LinearMomentX() const { return *data_->getArgument(4); } +void IfcStructuralLoadLinearForce::setLinearMomentX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcStructuralLoadLinearForce::hasLinearMomentY() const { return !data_->getArgument(5)->isNull(); } +double IfcStructuralLoadLinearForce::LinearMomentY() const { return *data_->getArgument(5); } +void IfcStructuralLoadLinearForce::setLinearMomentY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcStructuralLoadLinearForce::hasLinearMomentZ() const { return !data_->getArgument(6)->isNull(); } +double IfcStructuralLoadLinearForce::LinearMomentZ() const { return *data_->getArgument(6); } +void IfcStructuralLoadLinearForce::setLinearMomentZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcStructuralLoadLinearForce::declaration() const { return *IfcStructuralLoadLinearForce_type; } Type::Enum IfcStructuralLoadLinearForce::Class() { return Type::IfcStructuralLoadLinearForce; } -IfcStructuralLoadLinearForce::IfcStructuralLoadLinearForce(IfcAbstractEntity* e) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadLinearForce)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadLinearForce::IfcStructuralLoadLinearForce(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearForceX, boost::optional< double > v3_LinearForceY, boost::optional< double > v4_LinearForceZ, boost::optional< double > v5_LinearMomentX, boost::optional< double > v6_LinearMomentY, boost::optional< double > v7_LinearMomentZ) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_LinearForceX) { e->setArgument(1,(*v2_LinearForceX)); } else { e->setArgument(1); } if (v3_LinearForceY) { e->setArgument(2,(*v3_LinearForceY)); } else { e->setArgument(2); } if (v4_LinearForceZ) { e->setArgument(3,(*v4_LinearForceZ)); } else { e->setArgument(3); } if (v5_LinearMomentX) { e->setArgument(4,(*v5_LinearMomentX)); } else { e->setArgument(4); } if (v6_LinearMomentY) { e->setArgument(5,(*v6_LinearMomentY)); } else { e->setArgument(5); } if (v7_LinearMomentZ) { e->setArgument(6,(*v7_LinearMomentZ)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoadLinearForce::IfcStructuralLoadLinearForce(IfcAbstractEntity* e) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadLinearForce)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadLinearForce::IfcStructuralLoadLinearForce(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearForceX, boost::optional< double > v3_LinearForceY, boost::optional< double > v4_LinearForceZ, boost::optional< double > v5_LinearMomentX, boost::optional< double > v6_LinearMomentY, boost::optional< double > v7_LinearMomentZ) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_LinearForceX) { e->setArgument(1,(*v2_LinearForceX)); } else { e->setArgument(1); } if (v3_LinearForceY) { e->setArgument(2,(*v3_LinearForceY)); } else { e->setArgument(2); } if (v4_LinearForceZ) { e->setArgument(3,(*v4_LinearForceZ)); } else { e->setArgument(3); } if (v5_LinearMomentX) { e->setArgument(4,(*v5_LinearMomentX)); } else { e->setArgument(4); } if (v6_LinearMomentY) { e->setArgument(5,(*v6_LinearMomentY)); } else { e->setArgument(5); } if (v7_LinearMomentZ) { e->setArgument(6,(*v7_LinearMomentZ)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLoadPlanarForce -bool IfcStructuralLoadPlanarForce::hasPlanarForceX() const { return !entity->getArgument(1)->isNull(); } -double IfcStructuralLoadPlanarForce::PlanarForceX() const { return *entity->getArgument(1); } -void IfcStructuralLoadPlanarForce::setPlanarForceX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcStructuralLoadPlanarForce::hasPlanarForceY() const { return !entity->getArgument(2)->isNull(); } -double IfcStructuralLoadPlanarForce::PlanarForceY() const { return *entity->getArgument(2); } -void IfcStructuralLoadPlanarForce::setPlanarForceY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcStructuralLoadPlanarForce::hasPlanarForceZ() const { return !entity->getArgument(3)->isNull(); } -double IfcStructuralLoadPlanarForce::PlanarForceZ() const { return *entity->getArgument(3); } -void IfcStructuralLoadPlanarForce::setPlanarForceZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcStructuralLoadPlanarForce::is(Type::Enum v) const { return v == Type::IfcStructuralLoadPlanarForce || IfcStructuralLoadStatic::is(v); } -Type::Enum IfcStructuralLoadPlanarForce::type() const { return Type::IfcStructuralLoadPlanarForce; } +bool IfcStructuralLoadPlanarForce::hasPlanarForceX() const { return !data_->getArgument(1)->isNull(); } +double IfcStructuralLoadPlanarForce::PlanarForceX() const { return *data_->getArgument(1); } +void IfcStructuralLoadPlanarForce::setPlanarForceX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcStructuralLoadPlanarForce::hasPlanarForceY() const { return !data_->getArgument(2)->isNull(); } +double IfcStructuralLoadPlanarForce::PlanarForceY() const { return *data_->getArgument(2); } +void IfcStructuralLoadPlanarForce::setPlanarForceY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcStructuralLoadPlanarForce::hasPlanarForceZ() const { return !data_->getArgument(3)->isNull(); } +double IfcStructuralLoadPlanarForce::PlanarForceZ() const { return *data_->getArgument(3); } +void IfcStructuralLoadPlanarForce::setPlanarForceZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcStructuralLoadPlanarForce::declaration() const { return *IfcStructuralLoadPlanarForce_type; } Type::Enum IfcStructuralLoadPlanarForce::Class() { return Type::IfcStructuralLoadPlanarForce; } -IfcStructuralLoadPlanarForce::IfcStructuralLoadPlanarForce(IfcAbstractEntity* e) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadPlanarForce)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadPlanarForce::IfcStructuralLoadPlanarForce(boost::optional< std::string > v1_Name, boost::optional< double > v2_PlanarForceX, boost::optional< double > v3_PlanarForceY, boost::optional< double > v4_PlanarForceZ) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_PlanarForceX) { e->setArgument(1,(*v2_PlanarForceX)); } else { e->setArgument(1); } if (v3_PlanarForceY) { e->setArgument(2,(*v3_PlanarForceY)); } else { e->setArgument(2); } if (v4_PlanarForceZ) { e->setArgument(3,(*v4_PlanarForceZ)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoadPlanarForce::IfcStructuralLoadPlanarForce(IfcAbstractEntity* e) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadPlanarForce)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadPlanarForce::IfcStructuralLoadPlanarForce(boost::optional< std::string > v1_Name, boost::optional< double > v2_PlanarForceX, boost::optional< double > v3_PlanarForceY, boost::optional< double > v4_PlanarForceZ) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_PlanarForceX) { e->setArgument(1,(*v2_PlanarForceX)); } else { e->setArgument(1); } if (v3_PlanarForceY) { e->setArgument(2,(*v3_PlanarForceY)); } else { e->setArgument(2); } if (v4_PlanarForceZ) { e->setArgument(3,(*v4_PlanarForceZ)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLoadSingleDisplacement -bool IfcStructuralLoadSingleDisplacement::hasDisplacementX() const { return !entity->getArgument(1)->isNull(); } -double IfcStructuralLoadSingleDisplacement::DisplacementX() const { return *entity->getArgument(1); } -void IfcStructuralLoadSingleDisplacement::setDisplacementX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcStructuralLoadSingleDisplacement::hasDisplacementY() const { return !entity->getArgument(2)->isNull(); } -double IfcStructuralLoadSingleDisplacement::DisplacementY() const { return *entity->getArgument(2); } -void IfcStructuralLoadSingleDisplacement::setDisplacementY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcStructuralLoadSingleDisplacement::hasDisplacementZ() const { return !entity->getArgument(3)->isNull(); } -double IfcStructuralLoadSingleDisplacement::DisplacementZ() const { return *entity->getArgument(3); } -void IfcStructuralLoadSingleDisplacement::setDisplacementZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcStructuralLoadSingleDisplacement::hasRotationalDisplacementRX() const { return !entity->getArgument(4)->isNull(); } -double IfcStructuralLoadSingleDisplacement::RotationalDisplacementRX() const { return *entity->getArgument(4); } -void IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcStructuralLoadSingleDisplacement::hasRotationalDisplacementRY() const { return !entity->getArgument(5)->isNull(); } -double IfcStructuralLoadSingleDisplacement::RotationalDisplacementRY() const { return *entity->getArgument(5); } -void IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcStructuralLoadSingleDisplacement::hasRotationalDisplacementRZ() const { return !entity->getArgument(6)->isNull(); } -double IfcStructuralLoadSingleDisplacement::RotationalDisplacementRZ() const { return *entity->getArgument(6); } -void IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcStructuralLoadSingleDisplacement::is(Type::Enum v) const { return v == Type::IfcStructuralLoadSingleDisplacement || IfcStructuralLoadStatic::is(v); } -Type::Enum IfcStructuralLoadSingleDisplacement::type() const { return Type::IfcStructuralLoadSingleDisplacement; } +bool IfcStructuralLoadSingleDisplacement::hasDisplacementX() const { return !data_->getArgument(1)->isNull(); } +double IfcStructuralLoadSingleDisplacement::DisplacementX() const { return *data_->getArgument(1); } +void IfcStructuralLoadSingleDisplacement::setDisplacementX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcStructuralLoadSingleDisplacement::hasDisplacementY() const { return !data_->getArgument(2)->isNull(); } +double IfcStructuralLoadSingleDisplacement::DisplacementY() const { return *data_->getArgument(2); } +void IfcStructuralLoadSingleDisplacement::setDisplacementY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcStructuralLoadSingleDisplacement::hasDisplacementZ() const { return !data_->getArgument(3)->isNull(); } +double IfcStructuralLoadSingleDisplacement::DisplacementZ() const { return *data_->getArgument(3); } +void IfcStructuralLoadSingleDisplacement::setDisplacementZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcStructuralLoadSingleDisplacement::hasRotationalDisplacementRX() const { return !data_->getArgument(4)->isNull(); } +double IfcStructuralLoadSingleDisplacement::RotationalDisplacementRX() const { return *data_->getArgument(4); } +void IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcStructuralLoadSingleDisplacement::hasRotationalDisplacementRY() const { return !data_->getArgument(5)->isNull(); } +double IfcStructuralLoadSingleDisplacement::RotationalDisplacementRY() const { return *data_->getArgument(5); } +void IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcStructuralLoadSingleDisplacement::hasRotationalDisplacementRZ() const { return !data_->getArgument(6)->isNull(); } +double IfcStructuralLoadSingleDisplacement::RotationalDisplacementRZ() const { return *data_->getArgument(6); } +void IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcStructuralLoadSingleDisplacement::declaration() const { return *IfcStructuralLoadSingleDisplacement_type; } Type::Enum IfcStructuralLoadSingleDisplacement::Class() { return Type::IfcStructuralLoadSingleDisplacement; } -IfcStructuralLoadSingleDisplacement::IfcStructuralLoadSingleDisplacement(IfcAbstractEntity* e) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadSingleDisplacement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadSingleDisplacement::IfcStructuralLoadSingleDisplacement(boost::optional< std::string > v1_Name, boost::optional< double > v2_DisplacementX, boost::optional< double > v3_DisplacementY, boost::optional< double > v4_DisplacementZ, boost::optional< double > v5_RotationalDisplacementRX, boost::optional< double > v6_RotationalDisplacementRY, boost::optional< double > v7_RotationalDisplacementRZ) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DisplacementX) { e->setArgument(1,(*v2_DisplacementX)); } else { e->setArgument(1); } if (v3_DisplacementY) { e->setArgument(2,(*v3_DisplacementY)); } else { e->setArgument(2); } if (v4_DisplacementZ) { e->setArgument(3,(*v4_DisplacementZ)); } else { e->setArgument(3); } if (v5_RotationalDisplacementRX) { e->setArgument(4,(*v5_RotationalDisplacementRX)); } else { e->setArgument(4); } if (v6_RotationalDisplacementRY) { e->setArgument(5,(*v6_RotationalDisplacementRY)); } else { e->setArgument(5); } if (v7_RotationalDisplacementRZ) { e->setArgument(6,(*v7_RotationalDisplacementRZ)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoadSingleDisplacement::IfcStructuralLoadSingleDisplacement(IfcAbstractEntity* e) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadSingleDisplacement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadSingleDisplacement::IfcStructuralLoadSingleDisplacement(boost::optional< std::string > v1_Name, boost::optional< double > v2_DisplacementX, boost::optional< double > v3_DisplacementY, boost::optional< double > v4_DisplacementZ, boost::optional< double > v5_RotationalDisplacementRX, boost::optional< double > v6_RotationalDisplacementRY, boost::optional< double > v7_RotationalDisplacementRZ) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DisplacementX) { e->setArgument(1,(*v2_DisplacementX)); } else { e->setArgument(1); } if (v3_DisplacementY) { e->setArgument(2,(*v3_DisplacementY)); } else { e->setArgument(2); } if (v4_DisplacementZ) { e->setArgument(3,(*v4_DisplacementZ)); } else { e->setArgument(3); } if (v5_RotationalDisplacementRX) { e->setArgument(4,(*v5_RotationalDisplacementRX)); } else { e->setArgument(4); } if (v6_RotationalDisplacementRY) { e->setArgument(5,(*v6_RotationalDisplacementRY)); } else { e->setArgument(5); } if (v7_RotationalDisplacementRZ) { e->setArgument(6,(*v7_RotationalDisplacementRZ)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLoadSingleDisplacementDistortion -bool IfcStructuralLoadSingleDisplacementDistortion::hasDistortion() const { return !entity->getArgument(7)->isNull(); } -double IfcStructuralLoadSingleDisplacementDistortion::Distortion() const { return *entity->getArgument(7); } -void IfcStructuralLoadSingleDisplacementDistortion::setDistortion(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcStructuralLoadSingleDisplacementDistortion::is(Type::Enum v) const { return v == Type::IfcStructuralLoadSingleDisplacementDistortion || IfcStructuralLoadSingleDisplacement::is(v); } -Type::Enum IfcStructuralLoadSingleDisplacementDistortion::type() const { return Type::IfcStructuralLoadSingleDisplacementDistortion; } +bool IfcStructuralLoadSingleDisplacementDistortion::hasDistortion() const { return !data_->getArgument(7)->isNull(); } +double IfcStructuralLoadSingleDisplacementDistortion::Distortion() const { return *data_->getArgument(7); } +void IfcStructuralLoadSingleDisplacementDistortion::setDistortion(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcStructuralLoadSingleDisplacementDistortion::declaration() const { return *IfcStructuralLoadSingleDisplacementDistortion_type; } Type::Enum IfcStructuralLoadSingleDisplacementDistortion::Class() { return Type::IfcStructuralLoadSingleDisplacementDistortion; } -IfcStructuralLoadSingleDisplacementDistortion::IfcStructuralLoadSingleDisplacementDistortion(IfcAbstractEntity* e) : IfcStructuralLoadSingleDisplacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadSingleDisplacementDistortion)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadSingleDisplacementDistortion::IfcStructuralLoadSingleDisplacementDistortion(boost::optional< std::string > v1_Name, boost::optional< double > v2_DisplacementX, boost::optional< double > v3_DisplacementY, boost::optional< double > v4_DisplacementZ, boost::optional< double > v5_RotationalDisplacementRX, boost::optional< double > v6_RotationalDisplacementRY, boost::optional< double > v7_RotationalDisplacementRZ, boost::optional< double > v8_Distortion) : IfcStructuralLoadSingleDisplacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DisplacementX) { e->setArgument(1,(*v2_DisplacementX)); } else { e->setArgument(1); } if (v3_DisplacementY) { e->setArgument(2,(*v3_DisplacementY)); } else { e->setArgument(2); } if (v4_DisplacementZ) { e->setArgument(3,(*v4_DisplacementZ)); } else { e->setArgument(3); } if (v5_RotationalDisplacementRX) { e->setArgument(4,(*v5_RotationalDisplacementRX)); } else { e->setArgument(4); } if (v6_RotationalDisplacementRY) { e->setArgument(5,(*v6_RotationalDisplacementRY)); } else { e->setArgument(5); } if (v7_RotationalDisplacementRZ) { e->setArgument(6,(*v7_RotationalDisplacementRZ)); } else { e->setArgument(6); } if (v8_Distortion) { e->setArgument(7,(*v8_Distortion)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoadSingleDisplacementDistortion::IfcStructuralLoadSingleDisplacementDistortion(IfcAbstractEntity* e) : IfcStructuralLoadSingleDisplacement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadSingleDisplacementDistortion)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadSingleDisplacementDistortion::IfcStructuralLoadSingleDisplacementDistortion(boost::optional< std::string > v1_Name, boost::optional< double > v2_DisplacementX, boost::optional< double > v3_DisplacementY, boost::optional< double > v4_DisplacementZ, boost::optional< double > v5_RotationalDisplacementRX, boost::optional< double > v6_RotationalDisplacementRY, boost::optional< double > v7_RotationalDisplacementRZ, boost::optional< double > v8_Distortion) : IfcStructuralLoadSingleDisplacement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DisplacementX) { e->setArgument(1,(*v2_DisplacementX)); } else { e->setArgument(1); } if (v3_DisplacementY) { e->setArgument(2,(*v3_DisplacementY)); } else { e->setArgument(2); } if (v4_DisplacementZ) { e->setArgument(3,(*v4_DisplacementZ)); } else { e->setArgument(3); } if (v5_RotationalDisplacementRX) { e->setArgument(4,(*v5_RotationalDisplacementRX)); } else { e->setArgument(4); } if (v6_RotationalDisplacementRY) { e->setArgument(5,(*v6_RotationalDisplacementRY)); } else { e->setArgument(5); } if (v7_RotationalDisplacementRZ) { e->setArgument(6,(*v7_RotationalDisplacementRZ)); } else { e->setArgument(6); } if (v8_Distortion) { e->setArgument(7,(*v8_Distortion)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLoadSingleForce -bool IfcStructuralLoadSingleForce::hasForceX() const { return !entity->getArgument(1)->isNull(); } -double IfcStructuralLoadSingleForce::ForceX() const { return *entity->getArgument(1); } -void IfcStructuralLoadSingleForce::setForceX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcStructuralLoadSingleForce::hasForceY() const { return !entity->getArgument(2)->isNull(); } -double IfcStructuralLoadSingleForce::ForceY() const { return *entity->getArgument(2); } -void IfcStructuralLoadSingleForce::setForceY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcStructuralLoadSingleForce::hasForceZ() const { return !entity->getArgument(3)->isNull(); } -double IfcStructuralLoadSingleForce::ForceZ() const { return *entity->getArgument(3); } -void IfcStructuralLoadSingleForce::setForceZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcStructuralLoadSingleForce::hasMomentX() const { return !entity->getArgument(4)->isNull(); } -double IfcStructuralLoadSingleForce::MomentX() const { return *entity->getArgument(4); } -void IfcStructuralLoadSingleForce::setMomentX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcStructuralLoadSingleForce::hasMomentY() const { return !entity->getArgument(5)->isNull(); } -double IfcStructuralLoadSingleForce::MomentY() const { return *entity->getArgument(5); } -void IfcStructuralLoadSingleForce::setMomentY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcStructuralLoadSingleForce::hasMomentZ() const { return !entity->getArgument(6)->isNull(); } -double IfcStructuralLoadSingleForce::MomentZ() const { return *entity->getArgument(6); } -void IfcStructuralLoadSingleForce::setMomentZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcStructuralLoadSingleForce::is(Type::Enum v) const { return v == Type::IfcStructuralLoadSingleForce || IfcStructuralLoadStatic::is(v); } -Type::Enum IfcStructuralLoadSingleForce::type() const { return Type::IfcStructuralLoadSingleForce; } +bool IfcStructuralLoadSingleForce::hasForceX() const { return !data_->getArgument(1)->isNull(); } +double IfcStructuralLoadSingleForce::ForceX() const { return *data_->getArgument(1); } +void IfcStructuralLoadSingleForce::setForceX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcStructuralLoadSingleForce::hasForceY() const { return !data_->getArgument(2)->isNull(); } +double IfcStructuralLoadSingleForce::ForceY() const { return *data_->getArgument(2); } +void IfcStructuralLoadSingleForce::setForceY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcStructuralLoadSingleForce::hasForceZ() const { return !data_->getArgument(3)->isNull(); } +double IfcStructuralLoadSingleForce::ForceZ() const { return *data_->getArgument(3); } +void IfcStructuralLoadSingleForce::setForceZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcStructuralLoadSingleForce::hasMomentX() const { return !data_->getArgument(4)->isNull(); } +double IfcStructuralLoadSingleForce::MomentX() const { return *data_->getArgument(4); } +void IfcStructuralLoadSingleForce::setMomentX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcStructuralLoadSingleForce::hasMomentY() const { return !data_->getArgument(5)->isNull(); } +double IfcStructuralLoadSingleForce::MomentY() const { return *data_->getArgument(5); } +void IfcStructuralLoadSingleForce::setMomentY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcStructuralLoadSingleForce::hasMomentZ() const { return !data_->getArgument(6)->isNull(); } +double IfcStructuralLoadSingleForce::MomentZ() const { return *data_->getArgument(6); } +void IfcStructuralLoadSingleForce::setMomentZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcStructuralLoadSingleForce::declaration() const { return *IfcStructuralLoadSingleForce_type; } Type::Enum IfcStructuralLoadSingleForce::Class() { return Type::IfcStructuralLoadSingleForce; } -IfcStructuralLoadSingleForce::IfcStructuralLoadSingleForce(IfcAbstractEntity* e) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadSingleForce)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadSingleForce::IfcStructuralLoadSingleForce(boost::optional< std::string > v1_Name, boost::optional< double > v2_ForceX, boost::optional< double > v3_ForceY, boost::optional< double > v4_ForceZ, boost::optional< double > v5_MomentX, boost::optional< double > v6_MomentY, boost::optional< double > v7_MomentZ) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_ForceX) { e->setArgument(1,(*v2_ForceX)); } else { e->setArgument(1); } if (v3_ForceY) { e->setArgument(2,(*v3_ForceY)); } else { e->setArgument(2); } if (v4_ForceZ) { e->setArgument(3,(*v4_ForceZ)); } else { e->setArgument(3); } if (v5_MomentX) { e->setArgument(4,(*v5_MomentX)); } else { e->setArgument(4); } if (v6_MomentY) { e->setArgument(5,(*v6_MomentY)); } else { e->setArgument(5); } if (v7_MomentZ) { e->setArgument(6,(*v7_MomentZ)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoadSingleForce::IfcStructuralLoadSingleForce(IfcAbstractEntity* e) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadSingleForce)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadSingleForce::IfcStructuralLoadSingleForce(boost::optional< std::string > v1_Name, boost::optional< double > v2_ForceX, boost::optional< double > v3_ForceY, boost::optional< double > v4_ForceZ, boost::optional< double > v5_MomentX, boost::optional< double > v6_MomentY, boost::optional< double > v7_MomentZ) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_ForceX) { e->setArgument(1,(*v2_ForceX)); } else { e->setArgument(1); } if (v3_ForceY) { e->setArgument(2,(*v3_ForceY)); } else { e->setArgument(2); } if (v4_ForceZ) { e->setArgument(3,(*v4_ForceZ)); } else { e->setArgument(3); } if (v5_MomentX) { e->setArgument(4,(*v5_MomentX)); } else { e->setArgument(4); } if (v6_MomentY) { e->setArgument(5,(*v6_MomentY)); } else { e->setArgument(5); } if (v7_MomentZ) { e->setArgument(6,(*v7_MomentZ)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLoadSingleForceWarping -bool IfcStructuralLoadSingleForceWarping::hasWarpingMoment() const { return !entity->getArgument(7)->isNull(); } -double IfcStructuralLoadSingleForceWarping::WarpingMoment() const { return *entity->getArgument(7); } -void IfcStructuralLoadSingleForceWarping::setWarpingMoment(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcStructuralLoadSingleForceWarping::is(Type::Enum v) const { return v == Type::IfcStructuralLoadSingleForceWarping || IfcStructuralLoadSingleForce::is(v); } -Type::Enum IfcStructuralLoadSingleForceWarping::type() const { return Type::IfcStructuralLoadSingleForceWarping; } +bool IfcStructuralLoadSingleForceWarping::hasWarpingMoment() const { return !data_->getArgument(7)->isNull(); } +double IfcStructuralLoadSingleForceWarping::WarpingMoment() const { return *data_->getArgument(7); } +void IfcStructuralLoadSingleForceWarping::setWarpingMoment(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcStructuralLoadSingleForceWarping::declaration() const { return *IfcStructuralLoadSingleForceWarping_type; } Type::Enum IfcStructuralLoadSingleForceWarping::Class() { return Type::IfcStructuralLoadSingleForceWarping; } -IfcStructuralLoadSingleForceWarping::IfcStructuralLoadSingleForceWarping(IfcAbstractEntity* e) : IfcStructuralLoadSingleForce((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadSingleForceWarping)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadSingleForceWarping::IfcStructuralLoadSingleForceWarping(boost::optional< std::string > v1_Name, boost::optional< double > v2_ForceX, boost::optional< double > v3_ForceY, boost::optional< double > v4_ForceZ, boost::optional< double > v5_MomentX, boost::optional< double > v6_MomentY, boost::optional< double > v7_MomentZ, boost::optional< double > v8_WarpingMoment) : IfcStructuralLoadSingleForce((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_ForceX) { e->setArgument(1,(*v2_ForceX)); } else { e->setArgument(1); } if (v3_ForceY) { e->setArgument(2,(*v3_ForceY)); } else { e->setArgument(2); } if (v4_ForceZ) { e->setArgument(3,(*v4_ForceZ)); } else { e->setArgument(3); } if (v5_MomentX) { e->setArgument(4,(*v5_MomentX)); } else { e->setArgument(4); } if (v6_MomentY) { e->setArgument(5,(*v6_MomentY)); } else { e->setArgument(5); } if (v7_MomentZ) { e->setArgument(6,(*v7_MomentZ)); } else { e->setArgument(6); } if (v8_WarpingMoment) { e->setArgument(7,(*v8_WarpingMoment)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoadSingleForceWarping::IfcStructuralLoadSingleForceWarping(IfcAbstractEntity* e) : IfcStructuralLoadSingleForce((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadSingleForceWarping)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadSingleForceWarping::IfcStructuralLoadSingleForceWarping(boost::optional< std::string > v1_Name, boost::optional< double > v2_ForceX, boost::optional< double > v3_ForceY, boost::optional< double > v4_ForceZ, boost::optional< double > v5_MomentX, boost::optional< double > v6_MomentY, boost::optional< double > v7_MomentZ, boost::optional< double > v8_WarpingMoment) : IfcStructuralLoadSingleForce((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_ForceX) { e->setArgument(1,(*v2_ForceX)); } else { e->setArgument(1); } if (v3_ForceY) { e->setArgument(2,(*v3_ForceY)); } else { e->setArgument(2); } if (v4_ForceZ) { e->setArgument(3,(*v4_ForceZ)); } else { e->setArgument(3); } if (v5_MomentX) { e->setArgument(4,(*v5_MomentX)); } else { e->setArgument(4); } if (v6_MomentY) { e->setArgument(5,(*v6_MomentY)); } else { e->setArgument(5); } if (v7_MomentZ) { e->setArgument(6,(*v7_MomentZ)); } else { e->setArgument(6); } if (v8_WarpingMoment) { e->setArgument(7,(*v8_WarpingMoment)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLoadStatic -bool IfcStructuralLoadStatic::is(Type::Enum v) const { return v == Type::IfcStructuralLoadStatic || IfcStructuralLoad::is(v); } -Type::Enum IfcStructuralLoadStatic::type() const { return Type::IfcStructuralLoadStatic; } + + +const IfcParse::entity& IfcStructuralLoadStatic::declaration() const { return *IfcStructuralLoadStatic_type; } Type::Enum IfcStructuralLoadStatic::Class() { return Type::IfcStructuralLoadStatic; } -IfcStructuralLoadStatic::IfcStructuralLoadStatic(IfcAbstractEntity* e) : IfcStructuralLoad((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadStatic)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadStatic::IfcStructuralLoadStatic(boost::optional< std::string > v1_Name) : IfcStructuralLoad((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoadStatic::IfcStructuralLoadStatic(IfcAbstractEntity* e) : IfcStructuralLoad((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadStatic)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadStatic::IfcStructuralLoadStatic(boost::optional< std::string > v1_Name) : IfcStructuralLoad((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLoadTemperature -bool IfcStructuralLoadTemperature::hasDeltaT_Constant() const { return !entity->getArgument(1)->isNull(); } -double IfcStructuralLoadTemperature::DeltaT_Constant() const { return *entity->getArgument(1); } -void IfcStructuralLoadTemperature::setDeltaT_Constant(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcStructuralLoadTemperature::hasDeltaT_Y() const { return !entity->getArgument(2)->isNull(); } -double IfcStructuralLoadTemperature::DeltaT_Y() const { return *entity->getArgument(2); } -void IfcStructuralLoadTemperature::setDeltaT_Y(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcStructuralLoadTemperature::hasDeltaT_Z() const { return !entity->getArgument(3)->isNull(); } -double IfcStructuralLoadTemperature::DeltaT_Z() const { return *entity->getArgument(3); } -void IfcStructuralLoadTemperature::setDeltaT_Z(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcStructuralLoadTemperature::is(Type::Enum v) const { return v == Type::IfcStructuralLoadTemperature || IfcStructuralLoadStatic::is(v); } -Type::Enum IfcStructuralLoadTemperature::type() const { return Type::IfcStructuralLoadTemperature; } +bool IfcStructuralLoadTemperature::hasDeltaT_Constant() const { return !data_->getArgument(1)->isNull(); } +double IfcStructuralLoadTemperature::DeltaT_Constant() const { return *data_->getArgument(1); } +void IfcStructuralLoadTemperature::setDeltaT_Constant(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcStructuralLoadTemperature::hasDeltaT_Y() const { return !data_->getArgument(2)->isNull(); } +double IfcStructuralLoadTemperature::DeltaT_Y() const { return *data_->getArgument(2); } +void IfcStructuralLoadTemperature::setDeltaT_Y(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcStructuralLoadTemperature::hasDeltaT_Z() const { return !data_->getArgument(3)->isNull(); } +double IfcStructuralLoadTemperature::DeltaT_Z() const { return *data_->getArgument(3); } +void IfcStructuralLoadTemperature::setDeltaT_Z(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcStructuralLoadTemperature::declaration() const { return *IfcStructuralLoadTemperature_type; } Type::Enum IfcStructuralLoadTemperature::Class() { return Type::IfcStructuralLoadTemperature; } -IfcStructuralLoadTemperature::IfcStructuralLoadTemperature(IfcAbstractEntity* e) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadTemperature)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadTemperature::IfcStructuralLoadTemperature(boost::optional< std::string > v1_Name, boost::optional< double > v2_DeltaT_Constant, boost::optional< double > v3_DeltaT_Y, boost::optional< double > v4_DeltaT_Z) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DeltaT_Constant) { e->setArgument(1,(*v2_DeltaT_Constant)); } else { e->setArgument(1); } if (v3_DeltaT_Y) { e->setArgument(2,(*v3_DeltaT_Y)); } else { e->setArgument(2); } if (v4_DeltaT_Z) { e->setArgument(3,(*v4_DeltaT_Z)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoadTemperature::IfcStructuralLoadTemperature(IfcAbstractEntity* e) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadTemperature)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadTemperature::IfcStructuralLoadTemperature(boost::optional< std::string > v1_Name, boost::optional< double > v2_DeltaT_Constant, boost::optional< double > v3_DeltaT_Y, boost::optional< double > v4_DeltaT_Z) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DeltaT_Constant) { e->setArgument(1,(*v2_DeltaT_Constant)); } else { e->setArgument(1); } if (v3_DeltaT_Y) { e->setArgument(2,(*v3_DeltaT_Y)); } else { e->setArgument(2); } if (v4_DeltaT_Z) { e->setArgument(3,(*v4_DeltaT_Z)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralMember -IfcRelConnectsStructuralElement::list::ptr IfcStructuralMember::ReferencesElement() const { return entity->getInverse(Type::IfcRelConnectsStructuralElement, 5)->as(); } -IfcRelConnectsStructuralMember::list::ptr IfcStructuralMember::ConnectedBy() const { return entity->getInverse(Type::IfcRelConnectsStructuralMember, 4)->as(); } -bool IfcStructuralMember::is(Type::Enum v) const { return v == Type::IfcStructuralMember || IfcStructuralItem::is(v); } -Type::Enum IfcStructuralMember::type() const { return Type::IfcStructuralMember; } + +IfcRelConnectsStructuralElement::list::ptr IfcStructuralMember::ReferencesElement() const { return data_->getInverse(Type::IfcRelConnectsStructuralElement, 5)->as(); } +IfcRelConnectsStructuralMember::list::ptr IfcStructuralMember::ConnectedBy() const { return data_->getInverse(Type::IfcRelConnectsStructuralMember, 4)->as(); } + +const IfcParse::entity& IfcStructuralMember::declaration() const { return *IfcStructuralMember_type; } Type::Enum IfcStructuralMember::Class() { return Type::IfcStructuralMember; } -IfcStructuralMember::IfcStructuralMember(IfcAbstractEntity* e) : IfcStructuralItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralMember)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralMember::IfcStructuralMember(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation) : IfcStructuralItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); entity = e; EntityBuffer::Add(this); } +IfcStructuralMember::IfcStructuralMember(IfcAbstractEntity* e) : IfcStructuralItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralMember)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralMember::IfcStructuralMember(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation) : IfcStructuralItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralPlanarAction -IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralPlanarAction::ProjectedOrTrue() const { return IfcProjectedOrTrueLengthEnum::FromString(*entity->getArgument(11)); } -void IfcStructuralPlanarAction::setProjectedOrTrue(IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcProjectedOrTrueLengthEnum::ToString(v)); } -bool IfcStructuralPlanarAction::is(Type::Enum v) const { return v == Type::IfcStructuralPlanarAction || IfcStructuralAction::is(v); } -Type::Enum IfcStructuralPlanarAction::type() const { return Type::IfcStructuralPlanarAction; } +IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralPlanarAction::ProjectedOrTrue() const { return IfcProjectedOrTrueLengthEnum::FromString(*data_->getArgument(11)); } +void IfcStructuralPlanarAction::setProjectedOrTrue(IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcProjectedOrTrueLengthEnum::ToString(v)); } + + +const IfcParse::entity& IfcStructuralPlanarAction::declaration() const { return *IfcStructuralPlanarAction_type; } Type::Enum IfcStructuralPlanarAction::Class() { return Type::IfcStructuralPlanarAction; } -IfcStructuralPlanarAction::IfcStructuralPlanarAction(IfcAbstractEntity* e) : IfcStructuralAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralPlanarAction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralPlanarAction::IfcStructuralPlanarAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue) : IfcStructuralAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); e->setArgument(11,v12_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(v12_ProjectedOrTrue)); entity = e; EntityBuffer::Add(this); } +IfcStructuralPlanarAction::IfcStructuralPlanarAction(IfcAbstractEntity* e) : IfcStructuralAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralPlanarAction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralPlanarAction::IfcStructuralPlanarAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue) : IfcStructuralAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); e->setArgument(11,v12_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(v12_ProjectedOrTrue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralPlanarActionVarying -IfcShapeAspect* IfcStructuralPlanarActionVarying::VaryingAppliedLoadLocation() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(12))); } -void IfcStructuralPlanarActionVarying::setVaryingAppliedLoadLocation(IfcShapeAspect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -IfcTemplatedEntityList< IfcStructuralLoad >::ptr IfcStructuralPlanarActionVarying::SubsequentAppliedLoads() const { IfcEntityList::ptr es = *entity->getArgument(13); return es->as(); } -void IfcStructuralPlanarActionVarying::setSubsequentAppliedLoads(IfcTemplatedEntityList< IfcStructuralLoad >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v->generalize()); } -bool IfcStructuralPlanarActionVarying::is(Type::Enum v) const { return v == Type::IfcStructuralPlanarActionVarying || IfcStructuralPlanarAction::is(v); } -Type::Enum IfcStructuralPlanarActionVarying::type() const { return Type::IfcStructuralPlanarActionVarying; } +IfcShapeAspect* IfcStructuralPlanarActionVarying::VaryingAppliedLoadLocation() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(12))); } +void IfcStructuralPlanarActionVarying::setVaryingAppliedLoadLocation(IfcShapeAspect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +IfcTemplatedEntityList< IfcStructuralLoad >::ptr IfcStructuralPlanarActionVarying::SubsequentAppliedLoads() const { IfcEntityList::ptr es = *data_->getArgument(13); return es->as(); } +void IfcStructuralPlanarActionVarying::setSubsequentAppliedLoads(IfcTemplatedEntityList< IfcStructuralLoad >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v->generalize()); } + + +const IfcParse::entity& IfcStructuralPlanarActionVarying::declaration() const { return *IfcStructuralPlanarActionVarying_type; } Type::Enum IfcStructuralPlanarActionVarying::Class() { return Type::IfcStructuralPlanarActionVarying; } -IfcStructuralPlanarActionVarying::IfcStructuralPlanarActionVarying(IfcAbstractEntity* e) : IfcStructuralPlanarAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralPlanarActionVarying)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralPlanarActionVarying::IfcStructuralPlanarActionVarying(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue, IfcShapeAspect* v13_VaryingAppliedLoadLocation, IfcTemplatedEntityList< IfcStructuralLoad >::ptr v14_SubsequentAppliedLoads) : IfcStructuralPlanarAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); e->setArgument(11,v12_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(v12_ProjectedOrTrue)); e->setArgument(12,(v13_VaryingAppliedLoadLocation)); e->setArgument(13,(v14_SubsequentAppliedLoads)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcStructuralPlanarActionVarying::IfcStructuralPlanarActionVarying(IfcAbstractEntity* e) : IfcStructuralPlanarAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralPlanarActionVarying)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralPlanarActionVarying::IfcStructuralPlanarActionVarying(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue, IfcShapeAspect* v13_VaryingAppliedLoadLocation, IfcTemplatedEntityList< IfcStructuralLoad >::ptr v14_SubsequentAppliedLoads) : IfcStructuralPlanarAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); e->setArgument(11,v12_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(v12_ProjectedOrTrue)); e->setArgument(12,(v13_VaryingAppliedLoadLocation)); e->setArgument(13,(v14_SubsequentAppliedLoads)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralPointAction -bool IfcStructuralPointAction::is(Type::Enum v) const { return v == Type::IfcStructuralPointAction || IfcStructuralAction::is(v); } -Type::Enum IfcStructuralPointAction::type() const { return Type::IfcStructuralPointAction; } + + +const IfcParse::entity& IfcStructuralPointAction::declaration() const { return *IfcStructuralPointAction_type; } Type::Enum IfcStructuralPointAction::Class() { return Type::IfcStructuralPointAction; } -IfcStructuralPointAction::IfcStructuralPointAction(IfcAbstractEntity* e) : IfcStructuralAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralPointAction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralPointAction::IfcStructuralPointAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy) : IfcStructuralAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); entity = e; EntityBuffer::Add(this); } +IfcStructuralPointAction::IfcStructuralPointAction(IfcAbstractEntity* e) : IfcStructuralAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralPointAction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralPointAction::IfcStructuralPointAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy) : IfcStructuralAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); e->setArgument(9,(v10_DestabilizingLoad)); e->setArgument(10,(v11_CausedBy)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralPointConnection -bool IfcStructuralPointConnection::is(Type::Enum v) const { return v == Type::IfcStructuralPointConnection || IfcStructuralConnection::is(v); } -Type::Enum IfcStructuralPointConnection::type() const { return Type::IfcStructuralPointConnection; } + + +const IfcParse::entity& IfcStructuralPointConnection::declaration() const { return *IfcStructuralPointConnection_type; } Type::Enum IfcStructuralPointConnection::Class() { return Type::IfcStructuralPointConnection; } -IfcStructuralPointConnection::IfcStructuralPointConnection(IfcAbstractEntity* e) : IfcStructuralConnection((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralPointConnection)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralPointConnection::IfcStructuralPointConnection(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralConnection((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedCondition)); entity = e; EntityBuffer::Add(this); } +IfcStructuralPointConnection::IfcStructuralPointConnection(IfcAbstractEntity* e) : IfcStructuralConnection((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralPointConnection)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralPointConnection::IfcStructuralPointConnection(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralConnection((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedCondition)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralPointReaction -bool IfcStructuralPointReaction::is(Type::Enum v) const { return v == Type::IfcStructuralPointReaction || IfcStructuralReaction::is(v); } -Type::Enum IfcStructuralPointReaction::type() const { return Type::IfcStructuralPointReaction; } + + +const IfcParse::entity& IfcStructuralPointReaction::declaration() const { return *IfcStructuralPointReaction_type; } Type::Enum IfcStructuralPointReaction::Class() { return Type::IfcStructuralPointReaction; } -IfcStructuralPointReaction::IfcStructuralPointReaction(IfcAbstractEntity* e) : IfcStructuralReaction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralPointReaction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralPointReaction::IfcStructuralPointReaction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal) : IfcStructuralReaction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); entity = e; EntityBuffer::Add(this); } +IfcStructuralPointReaction::IfcStructuralPointReaction(IfcAbstractEntity* e) : IfcStructuralReaction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralPointReaction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralPointReaction::IfcStructuralPointReaction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal) : IfcStructuralReaction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralProfileProperties -bool IfcStructuralProfileProperties::hasTorsionalConstantX() const { return !entity->getArgument(7)->isNull(); } -double IfcStructuralProfileProperties::TorsionalConstantX() const { return *entity->getArgument(7); } -void IfcStructuralProfileProperties::setTorsionalConstantX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcStructuralProfileProperties::hasMomentOfInertiaYZ() const { return !entity->getArgument(8)->isNull(); } -double IfcStructuralProfileProperties::MomentOfInertiaYZ() const { return *entity->getArgument(8); } -void IfcStructuralProfileProperties::setMomentOfInertiaYZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcStructuralProfileProperties::hasMomentOfInertiaY() const { return !entity->getArgument(9)->isNull(); } -double IfcStructuralProfileProperties::MomentOfInertiaY() const { return *entity->getArgument(9); } -void IfcStructuralProfileProperties::setMomentOfInertiaY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcStructuralProfileProperties::hasMomentOfInertiaZ() const { return !entity->getArgument(10)->isNull(); } -double IfcStructuralProfileProperties::MomentOfInertiaZ() const { return *entity->getArgument(10); } -void IfcStructuralProfileProperties::setMomentOfInertiaZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcStructuralProfileProperties::hasWarpingConstant() const { return !entity->getArgument(11)->isNull(); } -double IfcStructuralProfileProperties::WarpingConstant() const { return *entity->getArgument(11); } -void IfcStructuralProfileProperties::setWarpingConstant(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcStructuralProfileProperties::hasShearCentreZ() const { return !entity->getArgument(12)->isNull(); } -double IfcStructuralProfileProperties::ShearCentreZ() const { return *entity->getArgument(12); } -void IfcStructuralProfileProperties::setShearCentreZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcStructuralProfileProperties::hasShearCentreY() const { return !entity->getArgument(13)->isNull(); } -double IfcStructuralProfileProperties::ShearCentreY() const { return *entity->getArgument(13); } -void IfcStructuralProfileProperties::setShearCentreY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcStructuralProfileProperties::hasShearDeformationAreaZ() const { return !entity->getArgument(14)->isNull(); } -double IfcStructuralProfileProperties::ShearDeformationAreaZ() const { return *entity->getArgument(14); } -void IfcStructuralProfileProperties::setShearDeformationAreaZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcStructuralProfileProperties::hasShearDeformationAreaY() const { return !entity->getArgument(15)->isNull(); } -double IfcStructuralProfileProperties::ShearDeformationAreaY() const { return *entity->getArgument(15); } -void IfcStructuralProfileProperties::setShearDeformationAreaY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v); } -bool IfcStructuralProfileProperties::hasMaximumSectionModulusY() const { return !entity->getArgument(16)->isNull(); } -double IfcStructuralProfileProperties::MaximumSectionModulusY() const { return *entity->getArgument(16); } -void IfcStructuralProfileProperties::setMaximumSectionModulusY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(16,v); } -bool IfcStructuralProfileProperties::hasMinimumSectionModulusY() const { return !entity->getArgument(17)->isNull(); } -double IfcStructuralProfileProperties::MinimumSectionModulusY() const { return *entity->getArgument(17); } -void IfcStructuralProfileProperties::setMinimumSectionModulusY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(17,v); } -bool IfcStructuralProfileProperties::hasMaximumSectionModulusZ() const { return !entity->getArgument(18)->isNull(); } -double IfcStructuralProfileProperties::MaximumSectionModulusZ() const { return *entity->getArgument(18); } -void IfcStructuralProfileProperties::setMaximumSectionModulusZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(18,v); } -bool IfcStructuralProfileProperties::hasMinimumSectionModulusZ() const { return !entity->getArgument(19)->isNull(); } -double IfcStructuralProfileProperties::MinimumSectionModulusZ() const { return *entity->getArgument(19); } -void IfcStructuralProfileProperties::setMinimumSectionModulusZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(19,v); } -bool IfcStructuralProfileProperties::hasTorsionalSectionModulus() const { return !entity->getArgument(20)->isNull(); } -double IfcStructuralProfileProperties::TorsionalSectionModulus() const { return *entity->getArgument(20); } -void IfcStructuralProfileProperties::setTorsionalSectionModulus(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(20,v); } -bool IfcStructuralProfileProperties::hasCentreOfGravityInX() const { return !entity->getArgument(21)->isNull(); } -double IfcStructuralProfileProperties::CentreOfGravityInX() const { return *entity->getArgument(21); } -void IfcStructuralProfileProperties::setCentreOfGravityInX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(21,v); } -bool IfcStructuralProfileProperties::hasCentreOfGravityInY() const { return !entity->getArgument(22)->isNull(); } -double IfcStructuralProfileProperties::CentreOfGravityInY() const { return *entity->getArgument(22); } -void IfcStructuralProfileProperties::setCentreOfGravityInY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(22,v); } -bool IfcStructuralProfileProperties::is(Type::Enum v) const { return v == Type::IfcStructuralProfileProperties || IfcGeneralProfileProperties::is(v); } -Type::Enum IfcStructuralProfileProperties::type() const { return Type::IfcStructuralProfileProperties; } +bool IfcStructuralProfileProperties::hasTorsionalConstantX() const { return !data_->getArgument(7)->isNull(); } +double IfcStructuralProfileProperties::TorsionalConstantX() const { return *data_->getArgument(7); } +void IfcStructuralProfileProperties::setTorsionalConstantX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcStructuralProfileProperties::hasMomentOfInertiaYZ() const { return !data_->getArgument(8)->isNull(); } +double IfcStructuralProfileProperties::MomentOfInertiaYZ() const { return *data_->getArgument(8); } +void IfcStructuralProfileProperties::setMomentOfInertiaYZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcStructuralProfileProperties::hasMomentOfInertiaY() const { return !data_->getArgument(9)->isNull(); } +double IfcStructuralProfileProperties::MomentOfInertiaY() const { return *data_->getArgument(9); } +void IfcStructuralProfileProperties::setMomentOfInertiaY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcStructuralProfileProperties::hasMomentOfInertiaZ() const { return !data_->getArgument(10)->isNull(); } +double IfcStructuralProfileProperties::MomentOfInertiaZ() const { return *data_->getArgument(10); } +void IfcStructuralProfileProperties::setMomentOfInertiaZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcStructuralProfileProperties::hasWarpingConstant() const { return !data_->getArgument(11)->isNull(); } +double IfcStructuralProfileProperties::WarpingConstant() const { return *data_->getArgument(11); } +void IfcStructuralProfileProperties::setWarpingConstant(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcStructuralProfileProperties::hasShearCentreZ() const { return !data_->getArgument(12)->isNull(); } +double IfcStructuralProfileProperties::ShearCentreZ() const { return *data_->getArgument(12); } +void IfcStructuralProfileProperties::setShearCentreZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcStructuralProfileProperties::hasShearCentreY() const { return !data_->getArgument(13)->isNull(); } +double IfcStructuralProfileProperties::ShearCentreY() const { return *data_->getArgument(13); } +void IfcStructuralProfileProperties::setShearCentreY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcStructuralProfileProperties::hasShearDeformationAreaZ() const { return !data_->getArgument(14)->isNull(); } +double IfcStructuralProfileProperties::ShearDeformationAreaZ() const { return *data_->getArgument(14); } +void IfcStructuralProfileProperties::setShearDeformationAreaZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } +bool IfcStructuralProfileProperties::hasShearDeformationAreaY() const { return !data_->getArgument(15)->isNull(); } +double IfcStructuralProfileProperties::ShearDeformationAreaY() const { return *data_->getArgument(15); } +void IfcStructuralProfileProperties::setShearDeformationAreaY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v); } +bool IfcStructuralProfileProperties::hasMaximumSectionModulusY() const { return !data_->getArgument(16)->isNull(); } +double IfcStructuralProfileProperties::MaximumSectionModulusY() const { return *data_->getArgument(16); } +void IfcStructuralProfileProperties::setMaximumSectionModulusY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(16,v); } +bool IfcStructuralProfileProperties::hasMinimumSectionModulusY() const { return !data_->getArgument(17)->isNull(); } +double IfcStructuralProfileProperties::MinimumSectionModulusY() const { return *data_->getArgument(17); } +void IfcStructuralProfileProperties::setMinimumSectionModulusY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(17,v); } +bool IfcStructuralProfileProperties::hasMaximumSectionModulusZ() const { return !data_->getArgument(18)->isNull(); } +double IfcStructuralProfileProperties::MaximumSectionModulusZ() const { return *data_->getArgument(18); } +void IfcStructuralProfileProperties::setMaximumSectionModulusZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(18,v); } +bool IfcStructuralProfileProperties::hasMinimumSectionModulusZ() const { return !data_->getArgument(19)->isNull(); } +double IfcStructuralProfileProperties::MinimumSectionModulusZ() const { return *data_->getArgument(19); } +void IfcStructuralProfileProperties::setMinimumSectionModulusZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(19,v); } +bool IfcStructuralProfileProperties::hasTorsionalSectionModulus() const { return !data_->getArgument(20)->isNull(); } +double IfcStructuralProfileProperties::TorsionalSectionModulus() const { return *data_->getArgument(20); } +void IfcStructuralProfileProperties::setTorsionalSectionModulus(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(20,v); } +bool IfcStructuralProfileProperties::hasCentreOfGravityInX() const { return !data_->getArgument(21)->isNull(); } +double IfcStructuralProfileProperties::CentreOfGravityInX() const { return *data_->getArgument(21); } +void IfcStructuralProfileProperties::setCentreOfGravityInX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(21,v); } +bool IfcStructuralProfileProperties::hasCentreOfGravityInY() const { return !data_->getArgument(22)->isNull(); } +double IfcStructuralProfileProperties::CentreOfGravityInY() const { return *data_->getArgument(22); } +void IfcStructuralProfileProperties::setCentreOfGravityInY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(22,v); } + + +const IfcParse::entity& IfcStructuralProfileProperties::declaration() const { return *IfcStructuralProfileProperties_type; } Type::Enum IfcStructuralProfileProperties::Class() { return Type::IfcStructuralProfileProperties; } -IfcStructuralProfileProperties::IfcStructuralProfileProperties(IfcAbstractEntity* e) : IfcGeneralProfileProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralProfileProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralProfileProperties::IfcStructuralProfileProperties(boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea, boost::optional< double > v8_TorsionalConstantX, boost::optional< double > v9_MomentOfInertiaYZ, boost::optional< double > v10_MomentOfInertiaY, boost::optional< double > v11_MomentOfInertiaZ, boost::optional< double > v12_WarpingConstant, boost::optional< double > v13_ShearCentreZ, boost::optional< double > v14_ShearCentreY, boost::optional< double > v15_ShearDeformationAreaZ, boost::optional< double > v16_ShearDeformationAreaY, boost::optional< double > v17_MaximumSectionModulusY, boost::optional< double > v18_MinimumSectionModulusY, boost::optional< double > v19_MaximumSectionModulusZ, boost::optional< double > v20_MinimumSectionModulusZ, boost::optional< double > v21_TorsionalSectionModulus, boost::optional< double > v22_CentreOfGravityInX, boost::optional< double > v23_CentreOfGravityInY) : IfcGeneralProfileProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ProfileName) { e->setArgument(0,(*v1_ProfileName)); } else { e->setArgument(0); } e->setArgument(1,(v2_ProfileDefinition)); if (v3_PhysicalWeight) { e->setArgument(2,(*v3_PhysicalWeight)); } else { e->setArgument(2); } if (v4_Perimeter) { e->setArgument(3,(*v4_Perimeter)); } else { e->setArgument(3); } if (v5_MinimumPlateThickness) { e->setArgument(4,(*v5_MinimumPlateThickness)); } else { e->setArgument(4); } if (v6_MaximumPlateThickness) { e->setArgument(5,(*v6_MaximumPlateThickness)); } else { e->setArgument(5); } if (v7_CrossSectionArea) { e->setArgument(6,(*v7_CrossSectionArea)); } else { e->setArgument(6); } if (v8_TorsionalConstantX) { e->setArgument(7,(*v8_TorsionalConstantX)); } else { e->setArgument(7); } if (v9_MomentOfInertiaYZ) { e->setArgument(8,(*v9_MomentOfInertiaYZ)); } else { e->setArgument(8); } if (v10_MomentOfInertiaY) { e->setArgument(9,(*v10_MomentOfInertiaY)); } else { e->setArgument(9); } if (v11_MomentOfInertiaZ) { e->setArgument(10,(*v11_MomentOfInertiaZ)); } else { e->setArgument(10); } if (v12_WarpingConstant) { e->setArgument(11,(*v12_WarpingConstant)); } else { e->setArgument(11); } if (v13_ShearCentreZ) { e->setArgument(12,(*v13_ShearCentreZ)); } else { e->setArgument(12); } if (v14_ShearCentreY) { e->setArgument(13,(*v14_ShearCentreY)); } else { e->setArgument(13); } if (v15_ShearDeformationAreaZ) { e->setArgument(14,(*v15_ShearDeformationAreaZ)); } else { e->setArgument(14); } if (v16_ShearDeformationAreaY) { e->setArgument(15,(*v16_ShearDeformationAreaY)); } else { e->setArgument(15); } if (v17_MaximumSectionModulusY) { e->setArgument(16,(*v17_MaximumSectionModulusY)); } else { e->setArgument(16); } if (v18_MinimumSectionModulusY) { e->setArgument(17,(*v18_MinimumSectionModulusY)); } else { e->setArgument(17); } if (v19_MaximumSectionModulusZ) { e->setArgument(18,(*v19_MaximumSectionModulusZ)); } else { e->setArgument(18); } if (v20_MinimumSectionModulusZ) { e->setArgument(19,(*v20_MinimumSectionModulusZ)); } else { e->setArgument(19); } if (v21_TorsionalSectionModulus) { e->setArgument(20,(*v21_TorsionalSectionModulus)); } else { e->setArgument(20); } if (v22_CentreOfGravityInX) { e->setArgument(21,(*v22_CentreOfGravityInX)); } else { e->setArgument(21); } if (v23_CentreOfGravityInY) { e->setArgument(22,(*v23_CentreOfGravityInY)); } else { e->setArgument(22); } entity = e; EntityBuffer::Add(this); } +IfcStructuralProfileProperties::IfcStructuralProfileProperties(IfcAbstractEntity* e) : IfcGeneralProfileProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralProfileProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralProfileProperties::IfcStructuralProfileProperties(boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea, boost::optional< double > v8_TorsionalConstantX, boost::optional< double > v9_MomentOfInertiaYZ, boost::optional< double > v10_MomentOfInertiaY, boost::optional< double > v11_MomentOfInertiaZ, boost::optional< double > v12_WarpingConstant, boost::optional< double > v13_ShearCentreZ, boost::optional< double > v14_ShearCentreY, boost::optional< double > v15_ShearDeformationAreaZ, boost::optional< double > v16_ShearDeformationAreaY, boost::optional< double > v17_MaximumSectionModulusY, boost::optional< double > v18_MinimumSectionModulusY, boost::optional< double > v19_MaximumSectionModulusZ, boost::optional< double > v20_MinimumSectionModulusZ, boost::optional< double > v21_TorsionalSectionModulus, boost::optional< double > v22_CentreOfGravityInX, boost::optional< double > v23_CentreOfGravityInY) : IfcGeneralProfileProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ProfileName) { e->setArgument(0,(*v1_ProfileName)); } else { e->setArgument(0); } e->setArgument(1,(v2_ProfileDefinition)); if (v3_PhysicalWeight) { e->setArgument(2,(*v3_PhysicalWeight)); } else { e->setArgument(2); } if (v4_Perimeter) { e->setArgument(3,(*v4_Perimeter)); } else { e->setArgument(3); } if (v5_MinimumPlateThickness) { e->setArgument(4,(*v5_MinimumPlateThickness)); } else { e->setArgument(4); } if (v6_MaximumPlateThickness) { e->setArgument(5,(*v6_MaximumPlateThickness)); } else { e->setArgument(5); } if (v7_CrossSectionArea) { e->setArgument(6,(*v7_CrossSectionArea)); } else { e->setArgument(6); } if (v8_TorsionalConstantX) { e->setArgument(7,(*v8_TorsionalConstantX)); } else { e->setArgument(7); } if (v9_MomentOfInertiaYZ) { e->setArgument(8,(*v9_MomentOfInertiaYZ)); } else { e->setArgument(8); } if (v10_MomentOfInertiaY) { e->setArgument(9,(*v10_MomentOfInertiaY)); } else { e->setArgument(9); } if (v11_MomentOfInertiaZ) { e->setArgument(10,(*v11_MomentOfInertiaZ)); } else { e->setArgument(10); } if (v12_WarpingConstant) { e->setArgument(11,(*v12_WarpingConstant)); } else { e->setArgument(11); } if (v13_ShearCentreZ) { e->setArgument(12,(*v13_ShearCentreZ)); } else { e->setArgument(12); } if (v14_ShearCentreY) { e->setArgument(13,(*v14_ShearCentreY)); } else { e->setArgument(13); } if (v15_ShearDeformationAreaZ) { e->setArgument(14,(*v15_ShearDeformationAreaZ)); } else { e->setArgument(14); } if (v16_ShearDeformationAreaY) { e->setArgument(15,(*v16_ShearDeformationAreaY)); } else { e->setArgument(15); } if (v17_MaximumSectionModulusY) { e->setArgument(16,(*v17_MaximumSectionModulusY)); } else { e->setArgument(16); } if (v18_MinimumSectionModulusY) { e->setArgument(17,(*v18_MinimumSectionModulusY)); } else { e->setArgument(17); } if (v19_MaximumSectionModulusZ) { e->setArgument(18,(*v19_MaximumSectionModulusZ)); } else { e->setArgument(18); } if (v20_MinimumSectionModulusZ) { e->setArgument(19,(*v20_MinimumSectionModulusZ)); } else { e->setArgument(19); } if (v21_TorsionalSectionModulus) { e->setArgument(20,(*v21_TorsionalSectionModulus)); } else { e->setArgument(20); } if (v22_CentreOfGravityInX) { e->setArgument(21,(*v22_CentreOfGravityInX)); } else { e->setArgument(21); } if (v23_CentreOfGravityInY) { e->setArgument(22,(*v23_CentreOfGravityInY)); } else { e->setArgument(22); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralReaction -IfcStructuralAction::list::ptr IfcStructuralReaction::Causes() const { return entity->getInverse(Type::IfcStructuralAction, 10)->as(); } -bool IfcStructuralReaction::is(Type::Enum v) const { return v == Type::IfcStructuralReaction || IfcStructuralActivity::is(v); } -Type::Enum IfcStructuralReaction::type() const { return Type::IfcStructuralReaction; } + +IfcStructuralAction::list::ptr IfcStructuralReaction::Causes() const { return data_->getInverse(Type::IfcStructuralAction, 10)->as(); } + +const IfcParse::entity& IfcStructuralReaction::declaration() const { return *IfcStructuralReaction_type; } Type::Enum IfcStructuralReaction::Class() { return Type::IfcStructuralReaction; } -IfcStructuralReaction::IfcStructuralReaction(IfcAbstractEntity* e) : IfcStructuralActivity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralReaction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralReaction::IfcStructuralReaction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal) : IfcStructuralActivity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); entity = e; EntityBuffer::Add(this); } +IfcStructuralReaction::IfcStructuralReaction(IfcAbstractEntity* e) : IfcStructuralActivity((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralReaction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralReaction::IfcStructuralReaction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal) : IfcStructuralActivity((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedLoad)); e->setArgument(8,v9_GlobalOrLocal,IfcGlobalOrLocalEnum::ToString(v9_GlobalOrLocal)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralResultGroup -IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum IfcStructuralResultGroup::TheoryType() const { return IfcAnalysisTheoryTypeEnum::FromString(*entity->getArgument(5)); } -void IfcStructuralResultGroup::setTheoryType(IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcAnalysisTheoryTypeEnum::ToString(v)); } -bool IfcStructuralResultGroup::hasResultForLoadGroup() const { return !entity->getArgument(6)->isNull(); } -IfcStructuralLoadGroup* IfcStructuralResultGroup::ResultForLoadGroup() const { return (IfcStructuralLoadGroup*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcStructuralResultGroup::setResultForLoadGroup(IfcStructuralLoadGroup* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcStructuralResultGroup::IsLinear() const { return *entity->getArgument(7); } -void IfcStructuralResultGroup::setIsLinear(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcStructuralAnalysisModel::list::ptr IfcStructuralResultGroup::ResultGroupFor() const { return entity->getInverse(Type::IfcStructuralAnalysisModel, 8)->as(); } -bool IfcStructuralResultGroup::is(Type::Enum v) const { return v == Type::IfcStructuralResultGroup || IfcGroup::is(v); } -Type::Enum IfcStructuralResultGroup::type() const { return Type::IfcStructuralResultGroup; } +IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum IfcStructuralResultGroup::TheoryType() const { return IfcAnalysisTheoryTypeEnum::FromString(*data_->getArgument(5)); } +void IfcStructuralResultGroup::setTheoryType(IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcAnalysisTheoryTypeEnum::ToString(v)); } +bool IfcStructuralResultGroup::hasResultForLoadGroup() const { return !data_->getArgument(6)->isNull(); } +IfcStructuralLoadGroup* IfcStructuralResultGroup::ResultForLoadGroup() const { return (IfcStructuralLoadGroup*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcStructuralResultGroup::setResultForLoadGroup(IfcStructuralLoadGroup* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcStructuralResultGroup::IsLinear() const { return *data_->getArgument(7); } +void IfcStructuralResultGroup::setIsLinear(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + +IfcStructuralAnalysisModel::list::ptr IfcStructuralResultGroup::ResultGroupFor() const { return data_->getInverse(Type::IfcStructuralAnalysisModel, 8)->as(); } + +const IfcParse::entity& IfcStructuralResultGroup::declaration() const { return *IfcStructuralResultGroup_type; } Type::Enum IfcStructuralResultGroup::Class() { return Type::IfcStructuralResultGroup; } -IfcStructuralResultGroup::IfcStructuralResultGroup(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralResultGroup)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralResultGroup::IfcStructuralResultGroup(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum v6_TheoryType, IfcStructuralLoadGroup* v7_ResultForLoadGroup, bool v8_IsLinear) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,v6_TheoryType,IfcAnalysisTheoryTypeEnum::ToString(v6_TheoryType)); e->setArgument(6,(v7_ResultForLoadGroup)); e->setArgument(7,(v8_IsLinear)); entity = e; EntityBuffer::Add(this); } +IfcStructuralResultGroup::IfcStructuralResultGroup(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralResultGroup)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralResultGroup::IfcStructuralResultGroup(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum v6_TheoryType, IfcStructuralLoadGroup* v7_ResultForLoadGroup, bool v8_IsLinear) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,v6_TheoryType,IfcAnalysisTheoryTypeEnum::ToString(v6_TheoryType)); e->setArgument(6,(v7_ResultForLoadGroup)); e->setArgument(7,(v8_IsLinear)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralSteelProfileProperties -bool IfcStructuralSteelProfileProperties::hasShearAreaZ() const { return !entity->getArgument(23)->isNull(); } -double IfcStructuralSteelProfileProperties::ShearAreaZ() const { return *entity->getArgument(23); } -void IfcStructuralSteelProfileProperties::setShearAreaZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(23,v); } -bool IfcStructuralSteelProfileProperties::hasShearAreaY() const { return !entity->getArgument(24)->isNull(); } -double IfcStructuralSteelProfileProperties::ShearAreaY() const { return *entity->getArgument(24); } -void IfcStructuralSteelProfileProperties::setShearAreaY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(24,v); } -bool IfcStructuralSteelProfileProperties::hasPlasticShapeFactorY() const { return !entity->getArgument(25)->isNull(); } -double IfcStructuralSteelProfileProperties::PlasticShapeFactorY() const { return *entity->getArgument(25); } -void IfcStructuralSteelProfileProperties::setPlasticShapeFactorY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(25,v); } -bool IfcStructuralSteelProfileProperties::hasPlasticShapeFactorZ() const { return !entity->getArgument(26)->isNull(); } -double IfcStructuralSteelProfileProperties::PlasticShapeFactorZ() const { return *entity->getArgument(26); } -void IfcStructuralSteelProfileProperties::setPlasticShapeFactorZ(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(26,v); } -bool IfcStructuralSteelProfileProperties::is(Type::Enum v) const { return v == Type::IfcStructuralSteelProfileProperties || IfcStructuralProfileProperties::is(v); } -Type::Enum IfcStructuralSteelProfileProperties::type() const { return Type::IfcStructuralSteelProfileProperties; } +bool IfcStructuralSteelProfileProperties::hasShearAreaZ() const { return !data_->getArgument(23)->isNull(); } +double IfcStructuralSteelProfileProperties::ShearAreaZ() const { return *data_->getArgument(23); } +void IfcStructuralSteelProfileProperties::setShearAreaZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(23,v); } +bool IfcStructuralSteelProfileProperties::hasShearAreaY() const { return !data_->getArgument(24)->isNull(); } +double IfcStructuralSteelProfileProperties::ShearAreaY() const { return *data_->getArgument(24); } +void IfcStructuralSteelProfileProperties::setShearAreaY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(24,v); } +bool IfcStructuralSteelProfileProperties::hasPlasticShapeFactorY() const { return !data_->getArgument(25)->isNull(); } +double IfcStructuralSteelProfileProperties::PlasticShapeFactorY() const { return *data_->getArgument(25); } +void IfcStructuralSteelProfileProperties::setPlasticShapeFactorY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(25,v); } +bool IfcStructuralSteelProfileProperties::hasPlasticShapeFactorZ() const { return !data_->getArgument(26)->isNull(); } +double IfcStructuralSteelProfileProperties::PlasticShapeFactorZ() const { return *data_->getArgument(26); } +void IfcStructuralSteelProfileProperties::setPlasticShapeFactorZ(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(26,v); } + + +const IfcParse::entity& IfcStructuralSteelProfileProperties::declaration() const { return *IfcStructuralSteelProfileProperties_type; } Type::Enum IfcStructuralSteelProfileProperties::Class() { return Type::IfcStructuralSteelProfileProperties; } -IfcStructuralSteelProfileProperties::IfcStructuralSteelProfileProperties(IfcAbstractEntity* e) : IfcStructuralProfileProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSteelProfileProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralSteelProfileProperties::IfcStructuralSteelProfileProperties(boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea, boost::optional< double > v8_TorsionalConstantX, boost::optional< double > v9_MomentOfInertiaYZ, boost::optional< double > v10_MomentOfInertiaY, boost::optional< double > v11_MomentOfInertiaZ, boost::optional< double > v12_WarpingConstant, boost::optional< double > v13_ShearCentreZ, boost::optional< double > v14_ShearCentreY, boost::optional< double > v15_ShearDeformationAreaZ, boost::optional< double > v16_ShearDeformationAreaY, boost::optional< double > v17_MaximumSectionModulusY, boost::optional< double > v18_MinimumSectionModulusY, boost::optional< double > v19_MaximumSectionModulusZ, boost::optional< double > v20_MinimumSectionModulusZ, boost::optional< double > v21_TorsionalSectionModulus, boost::optional< double > v22_CentreOfGravityInX, boost::optional< double > v23_CentreOfGravityInY, boost::optional< double > v24_ShearAreaZ, boost::optional< double > v25_ShearAreaY, boost::optional< double > v26_PlasticShapeFactorY, boost::optional< double > v27_PlasticShapeFactorZ) : IfcStructuralProfileProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ProfileName) { e->setArgument(0,(*v1_ProfileName)); } else { e->setArgument(0); } e->setArgument(1,(v2_ProfileDefinition)); if (v3_PhysicalWeight) { e->setArgument(2,(*v3_PhysicalWeight)); } else { e->setArgument(2); } if (v4_Perimeter) { e->setArgument(3,(*v4_Perimeter)); } else { e->setArgument(3); } if (v5_MinimumPlateThickness) { e->setArgument(4,(*v5_MinimumPlateThickness)); } else { e->setArgument(4); } if (v6_MaximumPlateThickness) { e->setArgument(5,(*v6_MaximumPlateThickness)); } else { e->setArgument(5); } if (v7_CrossSectionArea) { e->setArgument(6,(*v7_CrossSectionArea)); } else { e->setArgument(6); } if (v8_TorsionalConstantX) { e->setArgument(7,(*v8_TorsionalConstantX)); } else { e->setArgument(7); } if (v9_MomentOfInertiaYZ) { e->setArgument(8,(*v9_MomentOfInertiaYZ)); } else { e->setArgument(8); } if (v10_MomentOfInertiaY) { e->setArgument(9,(*v10_MomentOfInertiaY)); } else { e->setArgument(9); } if (v11_MomentOfInertiaZ) { e->setArgument(10,(*v11_MomentOfInertiaZ)); } else { e->setArgument(10); } if (v12_WarpingConstant) { e->setArgument(11,(*v12_WarpingConstant)); } else { e->setArgument(11); } if (v13_ShearCentreZ) { e->setArgument(12,(*v13_ShearCentreZ)); } else { e->setArgument(12); } if (v14_ShearCentreY) { e->setArgument(13,(*v14_ShearCentreY)); } else { e->setArgument(13); } if (v15_ShearDeformationAreaZ) { e->setArgument(14,(*v15_ShearDeformationAreaZ)); } else { e->setArgument(14); } if (v16_ShearDeformationAreaY) { e->setArgument(15,(*v16_ShearDeformationAreaY)); } else { e->setArgument(15); } if (v17_MaximumSectionModulusY) { e->setArgument(16,(*v17_MaximumSectionModulusY)); } else { e->setArgument(16); } if (v18_MinimumSectionModulusY) { e->setArgument(17,(*v18_MinimumSectionModulusY)); } else { e->setArgument(17); } if (v19_MaximumSectionModulusZ) { e->setArgument(18,(*v19_MaximumSectionModulusZ)); } else { e->setArgument(18); } if (v20_MinimumSectionModulusZ) { e->setArgument(19,(*v20_MinimumSectionModulusZ)); } else { e->setArgument(19); } if (v21_TorsionalSectionModulus) { e->setArgument(20,(*v21_TorsionalSectionModulus)); } else { e->setArgument(20); } if (v22_CentreOfGravityInX) { e->setArgument(21,(*v22_CentreOfGravityInX)); } else { e->setArgument(21); } if (v23_CentreOfGravityInY) { e->setArgument(22,(*v23_CentreOfGravityInY)); } else { e->setArgument(22); } if (v24_ShearAreaZ) { e->setArgument(23,(*v24_ShearAreaZ)); } else { e->setArgument(23); } if (v25_ShearAreaY) { e->setArgument(24,(*v25_ShearAreaY)); } else { e->setArgument(24); } if (v26_PlasticShapeFactorY) { e->setArgument(25,(*v26_PlasticShapeFactorY)); } else { e->setArgument(25); } if (v27_PlasticShapeFactorZ) { e->setArgument(26,(*v27_PlasticShapeFactorZ)); } else { e->setArgument(26); } entity = e; EntityBuffer::Add(this); } +IfcStructuralSteelProfileProperties::IfcStructuralSteelProfileProperties(IfcAbstractEntity* e) : IfcStructuralProfileProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSteelProfileProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralSteelProfileProperties::IfcStructuralSteelProfileProperties(boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea, boost::optional< double > v8_TorsionalConstantX, boost::optional< double > v9_MomentOfInertiaYZ, boost::optional< double > v10_MomentOfInertiaY, boost::optional< double > v11_MomentOfInertiaZ, boost::optional< double > v12_WarpingConstant, boost::optional< double > v13_ShearCentreZ, boost::optional< double > v14_ShearCentreY, boost::optional< double > v15_ShearDeformationAreaZ, boost::optional< double > v16_ShearDeformationAreaY, boost::optional< double > v17_MaximumSectionModulusY, boost::optional< double > v18_MinimumSectionModulusY, boost::optional< double > v19_MaximumSectionModulusZ, boost::optional< double > v20_MinimumSectionModulusZ, boost::optional< double > v21_TorsionalSectionModulus, boost::optional< double > v22_CentreOfGravityInX, boost::optional< double > v23_CentreOfGravityInY, boost::optional< double > v24_ShearAreaZ, boost::optional< double > v25_ShearAreaY, boost::optional< double > v26_PlasticShapeFactorY, boost::optional< double > v27_PlasticShapeFactorZ) : IfcStructuralProfileProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_ProfileName) { e->setArgument(0,(*v1_ProfileName)); } else { e->setArgument(0); } e->setArgument(1,(v2_ProfileDefinition)); if (v3_PhysicalWeight) { e->setArgument(2,(*v3_PhysicalWeight)); } else { e->setArgument(2); } if (v4_Perimeter) { e->setArgument(3,(*v4_Perimeter)); } else { e->setArgument(3); } if (v5_MinimumPlateThickness) { e->setArgument(4,(*v5_MinimumPlateThickness)); } else { e->setArgument(4); } if (v6_MaximumPlateThickness) { e->setArgument(5,(*v6_MaximumPlateThickness)); } else { e->setArgument(5); } if (v7_CrossSectionArea) { e->setArgument(6,(*v7_CrossSectionArea)); } else { e->setArgument(6); } if (v8_TorsionalConstantX) { e->setArgument(7,(*v8_TorsionalConstantX)); } else { e->setArgument(7); } if (v9_MomentOfInertiaYZ) { e->setArgument(8,(*v9_MomentOfInertiaYZ)); } else { e->setArgument(8); } if (v10_MomentOfInertiaY) { e->setArgument(9,(*v10_MomentOfInertiaY)); } else { e->setArgument(9); } if (v11_MomentOfInertiaZ) { e->setArgument(10,(*v11_MomentOfInertiaZ)); } else { e->setArgument(10); } if (v12_WarpingConstant) { e->setArgument(11,(*v12_WarpingConstant)); } else { e->setArgument(11); } if (v13_ShearCentreZ) { e->setArgument(12,(*v13_ShearCentreZ)); } else { e->setArgument(12); } if (v14_ShearCentreY) { e->setArgument(13,(*v14_ShearCentreY)); } else { e->setArgument(13); } if (v15_ShearDeformationAreaZ) { e->setArgument(14,(*v15_ShearDeformationAreaZ)); } else { e->setArgument(14); } if (v16_ShearDeformationAreaY) { e->setArgument(15,(*v16_ShearDeformationAreaY)); } else { e->setArgument(15); } if (v17_MaximumSectionModulusY) { e->setArgument(16,(*v17_MaximumSectionModulusY)); } else { e->setArgument(16); } if (v18_MinimumSectionModulusY) { e->setArgument(17,(*v18_MinimumSectionModulusY)); } else { e->setArgument(17); } if (v19_MaximumSectionModulusZ) { e->setArgument(18,(*v19_MaximumSectionModulusZ)); } else { e->setArgument(18); } if (v20_MinimumSectionModulusZ) { e->setArgument(19,(*v20_MinimumSectionModulusZ)); } else { e->setArgument(19); } if (v21_TorsionalSectionModulus) { e->setArgument(20,(*v21_TorsionalSectionModulus)); } else { e->setArgument(20); } if (v22_CentreOfGravityInX) { e->setArgument(21,(*v22_CentreOfGravityInX)); } else { e->setArgument(21); } if (v23_CentreOfGravityInY) { e->setArgument(22,(*v23_CentreOfGravityInY)); } else { e->setArgument(22); } if (v24_ShearAreaZ) { e->setArgument(23,(*v24_ShearAreaZ)); } else { e->setArgument(23); } if (v25_ShearAreaY) { e->setArgument(24,(*v25_ShearAreaY)); } else { e->setArgument(24); } if (v26_PlasticShapeFactorY) { e->setArgument(25,(*v26_PlasticShapeFactorY)); } else { e->setArgument(25); } if (v27_PlasticShapeFactorZ) { e->setArgument(26,(*v27_PlasticShapeFactorZ)); } else { e->setArgument(26); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralSurfaceConnection -bool IfcStructuralSurfaceConnection::is(Type::Enum v) const { return v == Type::IfcStructuralSurfaceConnection || IfcStructuralConnection::is(v); } -Type::Enum IfcStructuralSurfaceConnection::type() const { return Type::IfcStructuralSurfaceConnection; } + + +const IfcParse::entity& IfcStructuralSurfaceConnection::declaration() const { return *IfcStructuralSurfaceConnection_type; } Type::Enum IfcStructuralSurfaceConnection::Class() { return Type::IfcStructuralSurfaceConnection; } -IfcStructuralSurfaceConnection::IfcStructuralSurfaceConnection(IfcAbstractEntity* e) : IfcStructuralConnection((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSurfaceConnection)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralSurfaceConnection::IfcStructuralSurfaceConnection(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralConnection((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedCondition)); entity = e; EntityBuffer::Add(this); } +IfcStructuralSurfaceConnection::IfcStructuralSurfaceConnection(IfcAbstractEntity* e) : IfcStructuralConnection((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSurfaceConnection)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralSurfaceConnection::IfcStructuralSurfaceConnection(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralConnection((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,(v8_AppliedCondition)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralSurfaceMember -IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum IfcStructuralSurfaceMember::PredefinedType() const { return IfcStructuralSurfaceTypeEnum::FromString(*entity->getArgument(7)); } -void IfcStructuralSurfaceMember::setPredefinedType(IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcStructuralSurfaceTypeEnum::ToString(v)); } -bool IfcStructuralSurfaceMember::hasThickness() const { return !entity->getArgument(8)->isNull(); } -double IfcStructuralSurfaceMember::Thickness() const { return *entity->getArgument(8); } -void IfcStructuralSurfaceMember::setThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcStructuralSurfaceMember::is(Type::Enum v) const { return v == Type::IfcStructuralSurfaceMember || IfcStructuralMember::is(v); } -Type::Enum IfcStructuralSurfaceMember::type() const { return Type::IfcStructuralSurfaceMember; } +IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum IfcStructuralSurfaceMember::PredefinedType() const { return IfcStructuralSurfaceTypeEnum::FromString(*data_->getArgument(7)); } +void IfcStructuralSurfaceMember::setPredefinedType(IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcStructuralSurfaceTypeEnum::ToString(v)); } +bool IfcStructuralSurfaceMember::hasThickness() const { return !data_->getArgument(8)->isNull(); } +double IfcStructuralSurfaceMember::Thickness() const { return *data_->getArgument(8); } +void IfcStructuralSurfaceMember::setThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcStructuralSurfaceMember::declaration() const { return *IfcStructuralSurfaceMember_type; } Type::Enum IfcStructuralSurfaceMember::Class() { return Type::IfcStructuralSurfaceMember; } -IfcStructuralSurfaceMember::IfcStructuralSurfaceMember(IfcAbstractEntity* e) : IfcStructuralMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSurfaceMember)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralSurfaceMember::IfcStructuralSurfaceMember(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum v8_PredefinedType, boost::optional< double > v9_Thickness) : IfcStructuralMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,v8_PredefinedType,IfcStructuralSurfaceTypeEnum::ToString(v8_PredefinedType)); if (v9_Thickness) { e->setArgument(8,(*v9_Thickness)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcStructuralSurfaceMember::IfcStructuralSurfaceMember(IfcAbstractEntity* e) : IfcStructuralMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSurfaceMember)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralSurfaceMember::IfcStructuralSurfaceMember(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum v8_PredefinedType, boost::optional< double > v9_Thickness) : IfcStructuralMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,v8_PredefinedType,IfcStructuralSurfaceTypeEnum::ToString(v8_PredefinedType)); if (v9_Thickness) { e->setArgument(8,(*v9_Thickness)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralSurfaceMemberVarying -std::vector< double > /*[2:?]*/ IfcStructuralSurfaceMemberVarying::SubsequentThickness() const { return *entity->getArgument(9); } -void IfcStructuralSurfaceMemberVarying::setSubsequentThickness(std::vector< double > /*[2:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -IfcShapeAspect* IfcStructuralSurfaceMemberVarying::VaryingThicknessLocation() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcStructuralSurfaceMemberVarying::setVaryingThicknessLocation(IfcShapeAspect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcStructuralSurfaceMemberVarying::is(Type::Enum v) const { return v == Type::IfcStructuralSurfaceMemberVarying || IfcStructuralSurfaceMember::is(v); } -Type::Enum IfcStructuralSurfaceMemberVarying::type() const { return Type::IfcStructuralSurfaceMemberVarying; } +std::vector< double > /*[2:?]*/ IfcStructuralSurfaceMemberVarying::SubsequentThickness() const { return *data_->getArgument(9); } +void IfcStructuralSurfaceMemberVarying::setSubsequentThickness(std::vector< double > /*[2:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +IfcShapeAspect* IfcStructuralSurfaceMemberVarying::VaryingThicknessLocation() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcStructuralSurfaceMemberVarying::setVaryingThicknessLocation(IfcShapeAspect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcStructuralSurfaceMemberVarying::declaration() const { return *IfcStructuralSurfaceMemberVarying_type; } Type::Enum IfcStructuralSurfaceMemberVarying::Class() { return Type::IfcStructuralSurfaceMemberVarying; } -IfcStructuralSurfaceMemberVarying::IfcStructuralSurfaceMemberVarying(IfcAbstractEntity* e) : IfcStructuralSurfaceMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSurfaceMemberVarying)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralSurfaceMemberVarying::IfcStructuralSurfaceMemberVarying(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum v8_PredefinedType, boost::optional< double > v9_Thickness, std::vector< double > /*[2:?]*/ v10_SubsequentThickness, IfcShapeAspect* v11_VaryingThicknessLocation) : IfcStructuralSurfaceMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,v8_PredefinedType,IfcStructuralSurfaceTypeEnum::ToString(v8_PredefinedType)); if (v9_Thickness) { e->setArgument(8,(*v9_Thickness)); } else { e->setArgument(8); } e->setArgument(9,(v10_SubsequentThickness)); e->setArgument(10,(v11_VaryingThicknessLocation)); entity = e; EntityBuffer::Add(this); } +IfcStructuralSurfaceMemberVarying::IfcStructuralSurfaceMemberVarying(IfcAbstractEntity* e) : IfcStructuralSurfaceMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSurfaceMemberVarying)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralSurfaceMemberVarying::IfcStructuralSurfaceMemberVarying(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum v8_PredefinedType, boost::optional< double > v9_Thickness, std::vector< double > /*[2:?]*/ v10_SubsequentThickness, IfcShapeAspect* v11_VaryingThicknessLocation) : IfcStructuralSurfaceMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); e->setArgument(7,v8_PredefinedType,IfcStructuralSurfaceTypeEnum::ToString(v8_PredefinedType)); if (v9_Thickness) { e->setArgument(8,(*v9_Thickness)); } else { e->setArgument(8); } e->setArgument(9,(v10_SubsequentThickness)); e->setArgument(10,(v11_VaryingThicknessLocation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuredDimensionCallout -bool IfcStructuredDimensionCallout::is(Type::Enum v) const { return v == Type::IfcStructuredDimensionCallout || IfcDraughtingCallout::is(v); } -Type::Enum IfcStructuredDimensionCallout::type() const { return Type::IfcStructuredDimensionCallout; } + + +const IfcParse::entity& IfcStructuredDimensionCallout::declaration() const { return *IfcStructuredDimensionCallout_type; } Type::Enum IfcStructuredDimensionCallout::Class() { return Type::IfcStructuredDimensionCallout; } -IfcStructuredDimensionCallout::IfcStructuredDimensionCallout(IfcAbstractEntity* e) : IfcDraughtingCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuredDimensionCallout)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuredDimensionCallout::IfcStructuredDimensionCallout(IfcEntityList::ptr v1_Contents) : IfcDraughtingCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); entity = e; EntityBuffer::Add(this); } +IfcStructuredDimensionCallout::IfcStructuredDimensionCallout(IfcAbstractEntity* e) : IfcDraughtingCallout((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuredDimensionCallout)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuredDimensionCallout::IfcStructuredDimensionCallout(IfcEntityList::ptr v1_Contents) : IfcDraughtingCallout((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Contents)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStyleModel -bool IfcStyleModel::is(Type::Enum v) const { return v == Type::IfcStyleModel || IfcRepresentation::is(v); } -Type::Enum IfcStyleModel::type() const { return Type::IfcStyleModel; } + + +const IfcParse::entity& IfcStyleModel::declaration() const { return *IfcStyleModel_type; } Type::Enum IfcStyleModel::Class() { return Type::IfcStyleModel; } -IfcStyleModel::IfcStyleModel(IfcAbstractEntity* e) : IfcRepresentation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStyleModel)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStyleModel::IfcStyleModel(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcRepresentation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcStyleModel::IfcStyleModel(IfcAbstractEntity* e) : IfcRepresentation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStyleModel)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStyleModel::IfcStyleModel(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcRepresentation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStyledItem -bool IfcStyledItem::hasItem() const { return !entity->getArgument(0)->isNull(); } -IfcRepresentationItem* IfcStyledItem::Item() const { return (IfcRepresentationItem*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcStyledItem::setItem(IfcRepresentationItem* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr IfcStyledItem::Styles() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcStyledItem::setStyles(IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcStyledItem::hasName() const { return !entity->getArgument(2)->isNull(); } -std::string IfcStyledItem::Name() const { return *entity->getArgument(2); } -void IfcStyledItem::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcStyledItem::is(Type::Enum v) const { return v == Type::IfcStyledItem || IfcRepresentationItem::is(v); } -Type::Enum IfcStyledItem::type() const { return Type::IfcStyledItem; } +bool IfcStyledItem::hasItem() const { return !data_->getArgument(0)->isNull(); } +IfcRepresentationItem* IfcStyledItem::Item() const { return (IfcRepresentationItem*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcStyledItem::setItem(IfcRepresentationItem* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr IfcStyledItem::Styles() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcStyledItem::setStyles(IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +bool IfcStyledItem::hasName() const { return !data_->getArgument(2)->isNull(); } +std::string IfcStyledItem::Name() const { return *data_->getArgument(2); } +void IfcStyledItem::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcStyledItem::declaration() const { return *IfcStyledItem_type; } Type::Enum IfcStyledItem::Class() { return Type::IfcStyledItem; } -IfcStyledItem::IfcStyledItem(IfcAbstractEntity* e) : IfcRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStyledItem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStyledItem::IfcStyledItem(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcStyledItem::IfcStyledItem(IfcAbstractEntity* e) : IfcRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStyledItem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStyledItem::IfcStyledItem(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStyledRepresentation -bool IfcStyledRepresentation::is(Type::Enum v) const { return v == Type::IfcStyledRepresentation || IfcStyleModel::is(v); } -Type::Enum IfcStyledRepresentation::type() const { return Type::IfcStyledRepresentation; } + + +const IfcParse::entity& IfcStyledRepresentation::declaration() const { return *IfcStyledRepresentation_type; } Type::Enum IfcStyledRepresentation::Class() { return Type::IfcStyledRepresentation; } -IfcStyledRepresentation::IfcStyledRepresentation(IfcAbstractEntity* e) : IfcStyleModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStyledRepresentation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStyledRepresentation::IfcStyledRepresentation(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcStyleModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcStyledRepresentation::IfcStyledRepresentation(IfcAbstractEntity* e) : IfcStyleModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStyledRepresentation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStyledRepresentation::IfcStyledRepresentation(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcStyleModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSubContractResource -bool IfcSubContractResource::hasSubContractor() const { return !entity->getArgument(9)->isNull(); } -IfcActorSelect* IfcSubContractResource::SubContractor() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcSubContractResource::setSubContractor(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcSubContractResource::hasJobDescription() const { return !entity->getArgument(10)->isNull(); } -std::string IfcSubContractResource::JobDescription() const { return *entity->getArgument(10); } -void IfcSubContractResource::setJobDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcSubContractResource::is(Type::Enum v) const { return v == Type::IfcSubContractResource || IfcConstructionResource::is(v); } -Type::Enum IfcSubContractResource::type() const { return Type::IfcSubContractResource; } +bool IfcSubContractResource::hasSubContractor() const { return !data_->getArgument(9)->isNull(); } +IfcActorSelect* IfcSubContractResource::SubContractor() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcSubContractResource::setSubContractor(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcSubContractResource::hasJobDescription() const { return !data_->getArgument(10)->isNull(); } +std::string IfcSubContractResource::JobDescription() const { return *data_->getArgument(10); } +void IfcSubContractResource::setJobDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcSubContractResource::declaration() const { return *IfcSubContractResource_type; } Type::Enum IfcSubContractResource::Class() { return Type::IfcSubContractResource; } -IfcSubContractResource::IfcSubContractResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSubContractResource)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSubContractResource::IfcSubContractResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity, IfcActorSelect* v10_SubContractor, boost::optional< std::string > v11_JobDescription) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); e->setArgument(9,(v10_SubContractor)); if (v11_JobDescription) { e->setArgument(10,(*v11_JobDescription)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcSubContractResource::IfcSubContractResource(IfcAbstractEntity* e) : IfcConstructionResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSubContractResource)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSubContractResource::IfcSubContractResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity, IfcActorSelect* v10_SubContractor, boost::optional< std::string > v11_JobDescription) : IfcConstructionResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ResourceIdentifier) { e->setArgument(5,(*v6_ResourceIdentifier)); } else { e->setArgument(5); } if (v7_ResourceGroup) { e->setArgument(6,(*v7_ResourceGroup)); } else { e->setArgument(6); } if (v8_ResourceConsumption) { e->setArgument(7,*v8_ResourceConsumption,IfcResourceConsumptionEnum::ToString(*v8_ResourceConsumption)); } else { e->setArgument(7); } e->setArgument(8,(v9_BaseQuantity)); e->setArgument(9,(v10_SubContractor)); if (v11_JobDescription) { e->setArgument(10,(*v11_JobDescription)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSubedge -IfcEdge* IfcSubedge::ParentEdge() const { return (IfcEdge*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcSubedge::setParentEdge(IfcEdge* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcSubedge::is(Type::Enum v) const { return v == Type::IfcSubedge || IfcEdge::is(v); } -Type::Enum IfcSubedge::type() const { return Type::IfcSubedge; } +IfcEdge* IfcSubedge::ParentEdge() const { return (IfcEdge*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcSubedge::setParentEdge(IfcEdge* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcSubedge::declaration() const { return *IfcSubedge_type; } Type::Enum IfcSubedge::Class() { return Type::IfcSubedge; } -IfcSubedge::IfcSubedge(IfcAbstractEntity* e) : IfcEdge((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSubedge)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSubedge::IfcSubedge(IfcVertex* v1_EdgeStart, IfcVertex* v2_EdgeEnd, IfcEdge* v3_ParentEdge) : IfcEdge((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_EdgeStart)); e->setArgument(1,(v2_EdgeEnd)); e->setArgument(2,(v3_ParentEdge)); entity = e; EntityBuffer::Add(this); } +IfcSubedge::IfcSubedge(IfcAbstractEntity* e) : IfcEdge((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSubedge)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSubedge::IfcSubedge(IfcVertex* v1_EdgeStart, IfcVertex* v2_EdgeEnd, IfcEdge* v3_ParentEdge) : IfcEdge((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_EdgeStart)); e->setArgument(1,(v2_EdgeEnd)); e->setArgument(2,(v3_ParentEdge)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurface -bool IfcSurface::is(Type::Enum v) const { return v == Type::IfcSurface || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcSurface::type() const { return Type::IfcSurface; } + + +const IfcParse::entity& IfcSurface::declaration() const { return *IfcSurface_type; } Type::Enum IfcSurface::Class() { return Type::IfcSurface; } -IfcSurface::IfcSurface(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurface::IfcSurface() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcSurface::IfcSurface(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurface::IfcSurface() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurfaceCurveSweptAreaSolid -IfcCurve* IfcSurfaceCurveSweptAreaSolid::Directrix() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcSurfaceCurveSweptAreaSolid::setDirectrix(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -double IfcSurfaceCurveSweptAreaSolid::StartParam() const { return *entity->getArgument(3); } -void IfcSurfaceCurveSweptAreaSolid::setStartParam(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcSurfaceCurveSweptAreaSolid::EndParam() const { return *entity->getArgument(4); } -void IfcSurfaceCurveSweptAreaSolid::setEndParam(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcSurface* IfcSurfaceCurveSweptAreaSolid::ReferenceSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcSurfaceCurveSweptAreaSolid::setReferenceSurface(IfcSurface* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcSurfaceCurveSweptAreaSolid::is(Type::Enum v) const { return v == Type::IfcSurfaceCurveSweptAreaSolid || IfcSweptAreaSolid::is(v); } -Type::Enum IfcSurfaceCurveSweptAreaSolid::type() const { return Type::IfcSurfaceCurveSweptAreaSolid; } +IfcCurve* IfcSurfaceCurveSweptAreaSolid::Directrix() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcSurfaceCurveSweptAreaSolid::setDirectrix(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +double IfcSurfaceCurveSweptAreaSolid::StartParam() const { return *data_->getArgument(3); } +void IfcSurfaceCurveSweptAreaSolid::setStartParam(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcSurfaceCurveSweptAreaSolid::EndParam() const { return *data_->getArgument(4); } +void IfcSurfaceCurveSweptAreaSolid::setEndParam(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcSurface* IfcSurfaceCurveSweptAreaSolid::ReferenceSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcSurfaceCurveSweptAreaSolid::setReferenceSurface(IfcSurface* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcSurfaceCurveSweptAreaSolid::declaration() const { return *IfcSurfaceCurveSweptAreaSolid_type; } Type::Enum IfcSurfaceCurveSweptAreaSolid::Class() { return Type::IfcSurfaceCurveSweptAreaSolid; } -IfcSurfaceCurveSweptAreaSolid::IfcSurfaceCurveSweptAreaSolid(IfcAbstractEntity* e) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceCurveSweptAreaSolid)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceCurveSweptAreaSolid::IfcSurfaceCurveSweptAreaSolid(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcCurve* v3_Directrix, double v4_StartParam, double v5_EndParam, IfcSurface* v6_ReferenceSurface) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptArea)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_Directrix)); e->setArgument(3,(v4_StartParam)); e->setArgument(4,(v5_EndParam)); e->setArgument(5,(v6_ReferenceSurface)); entity = e; EntityBuffer::Add(this); } +IfcSurfaceCurveSweptAreaSolid::IfcSurfaceCurveSweptAreaSolid(IfcAbstractEntity* e) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceCurveSweptAreaSolid)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceCurveSweptAreaSolid::IfcSurfaceCurveSweptAreaSolid(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcCurve* v3_Directrix, double v4_StartParam, double v5_EndParam, IfcSurface* v6_ReferenceSurface) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptArea)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_Directrix)); e->setArgument(3,(v4_StartParam)); e->setArgument(4,(v5_EndParam)); e->setArgument(5,(v6_ReferenceSurface)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurfaceOfLinearExtrusion -IfcDirection* IfcSurfaceOfLinearExtrusion::ExtrudedDirection() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcSurfaceOfLinearExtrusion::setExtrudedDirection(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -double IfcSurfaceOfLinearExtrusion::Depth() const { return *entity->getArgument(3); } -void IfcSurfaceOfLinearExtrusion::setDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcSurfaceOfLinearExtrusion::is(Type::Enum v) const { return v == Type::IfcSurfaceOfLinearExtrusion || IfcSweptSurface::is(v); } -Type::Enum IfcSurfaceOfLinearExtrusion::type() const { return Type::IfcSurfaceOfLinearExtrusion; } +IfcDirection* IfcSurfaceOfLinearExtrusion::ExtrudedDirection() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcSurfaceOfLinearExtrusion::setExtrudedDirection(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +double IfcSurfaceOfLinearExtrusion::Depth() const { return *data_->getArgument(3); } +void IfcSurfaceOfLinearExtrusion::setDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcSurfaceOfLinearExtrusion::declaration() const { return *IfcSurfaceOfLinearExtrusion_type; } Type::Enum IfcSurfaceOfLinearExtrusion::Class() { return Type::IfcSurfaceOfLinearExtrusion; } -IfcSurfaceOfLinearExtrusion::IfcSurfaceOfLinearExtrusion(IfcAbstractEntity* e) : IfcSweptSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceOfLinearExtrusion)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceOfLinearExtrusion::IfcSurfaceOfLinearExtrusion(IfcProfileDef* v1_SweptCurve, IfcAxis2Placement3D* v2_Position, IfcDirection* v3_ExtrudedDirection, double v4_Depth) : IfcSweptSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptCurve)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_ExtrudedDirection)); e->setArgument(3,(v4_Depth)); entity = e; EntityBuffer::Add(this); } +IfcSurfaceOfLinearExtrusion::IfcSurfaceOfLinearExtrusion(IfcAbstractEntity* e) : IfcSweptSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceOfLinearExtrusion)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceOfLinearExtrusion::IfcSurfaceOfLinearExtrusion(IfcProfileDef* v1_SweptCurve, IfcAxis2Placement3D* v2_Position, IfcDirection* v3_ExtrudedDirection, double v4_Depth) : IfcSweptSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptCurve)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_ExtrudedDirection)); e->setArgument(3,(v4_Depth)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurfaceOfRevolution -IfcAxis1Placement* IfcSurfaceOfRevolution::AxisPosition() const { return (IfcAxis1Placement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcSurfaceOfRevolution::setAxisPosition(IfcAxis1Placement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcSurfaceOfRevolution::is(Type::Enum v) const { return v == Type::IfcSurfaceOfRevolution || IfcSweptSurface::is(v); } -Type::Enum IfcSurfaceOfRevolution::type() const { return Type::IfcSurfaceOfRevolution; } +IfcAxis1Placement* IfcSurfaceOfRevolution::AxisPosition() const { return (IfcAxis1Placement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcSurfaceOfRevolution::setAxisPosition(IfcAxis1Placement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcSurfaceOfRevolution::declaration() const { return *IfcSurfaceOfRevolution_type; } Type::Enum IfcSurfaceOfRevolution::Class() { return Type::IfcSurfaceOfRevolution; } -IfcSurfaceOfRevolution::IfcSurfaceOfRevolution(IfcAbstractEntity* e) : IfcSweptSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceOfRevolution)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceOfRevolution::IfcSurfaceOfRevolution(IfcProfileDef* v1_SweptCurve, IfcAxis2Placement3D* v2_Position, IfcAxis1Placement* v3_AxisPosition) : IfcSweptSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptCurve)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_AxisPosition)); entity = e; EntityBuffer::Add(this); } +IfcSurfaceOfRevolution::IfcSurfaceOfRevolution(IfcAbstractEntity* e) : IfcSweptSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceOfRevolution)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceOfRevolution::IfcSurfaceOfRevolution(IfcProfileDef* v1_SweptCurve, IfcAxis2Placement3D* v2_Position, IfcAxis1Placement* v3_AxisPosition) : IfcSweptSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptCurve)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_AxisPosition)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurfaceStyle -IfcSurfaceSide::IfcSurfaceSide IfcSurfaceStyle::Side() const { return IfcSurfaceSide::FromString(*entity->getArgument(1)); } -void IfcSurfaceStyle::setSide(IfcSurfaceSide::IfcSurfaceSide v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v,IfcSurfaceSide::ToString(v)); } -IfcEntityList::ptr IfcSurfaceStyle::Styles() const { return *entity->getArgument(2); } -void IfcSurfaceStyle::setStyles(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcSurfaceStyle::is(Type::Enum v) const { return v == Type::IfcSurfaceStyle || IfcPresentationStyle::is(v); } -Type::Enum IfcSurfaceStyle::type() const { return Type::IfcSurfaceStyle; } +IfcSurfaceSide::IfcSurfaceSide IfcSurfaceStyle::Side() const { return IfcSurfaceSide::FromString(*data_->getArgument(1)); } +void IfcSurfaceStyle::setSide(IfcSurfaceSide::IfcSurfaceSide v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v,IfcSurfaceSide::ToString(v)); } +IfcEntityList::ptr IfcSurfaceStyle::Styles() const { return *data_->getArgument(2); } +void IfcSurfaceStyle::setStyles(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcSurfaceStyle::declaration() const { return *IfcSurfaceStyle_type; } Type::Enum IfcSurfaceStyle::Class() { return Type::IfcSurfaceStyle; } -IfcSurfaceStyle::IfcSurfaceStyle(IfcAbstractEntity* e) : IfcPresentationStyle((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceStyle::IfcSurfaceStyle(boost::optional< std::string > v1_Name, IfcSurfaceSide::IfcSurfaceSide v2_Side, IfcEntityList::ptr v3_Styles) : IfcPresentationStyle((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,v2_Side,IfcSurfaceSide::ToString(v2_Side)); e->setArgument(2,(v3_Styles)); entity = e; EntityBuffer::Add(this); } +IfcSurfaceStyle::IfcSurfaceStyle(IfcAbstractEntity* e) : IfcPresentationStyle((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceStyle::IfcSurfaceStyle(boost::optional< std::string > v1_Name, IfcSurfaceSide::IfcSurfaceSide v2_Side, IfcEntityList::ptr v3_Styles) : IfcPresentationStyle((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,v2_Side,IfcSurfaceSide::ToString(v2_Side)); e->setArgument(2,(v3_Styles)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurfaceStyleLighting -IfcColourRgb* IfcSurfaceStyleLighting::DiffuseTransmissionColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcSurfaceStyleLighting::setDiffuseTransmissionColour(IfcColourRgb* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcColourRgb* IfcSurfaceStyleLighting::DiffuseReflectionColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcSurfaceStyleLighting::setDiffuseReflectionColour(IfcColourRgb* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcColourRgb* IfcSurfaceStyleLighting::TransmissionColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcSurfaceStyleLighting::setTransmissionColour(IfcColourRgb* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcColourRgb* IfcSurfaceStyleLighting::ReflectanceColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcSurfaceStyleLighting::setReflectanceColour(IfcColourRgb* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcSurfaceStyleLighting::is(Type::Enum v) const { return v == Type::IfcSurfaceStyleLighting; } -Type::Enum IfcSurfaceStyleLighting::type() const { return Type::IfcSurfaceStyleLighting; } +IfcColourRgb* IfcSurfaceStyleLighting::DiffuseTransmissionColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcSurfaceStyleLighting::setDiffuseTransmissionColour(IfcColourRgb* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcColourRgb* IfcSurfaceStyleLighting::DiffuseReflectionColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcSurfaceStyleLighting::setDiffuseReflectionColour(IfcColourRgb* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcColourRgb* IfcSurfaceStyleLighting::TransmissionColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcSurfaceStyleLighting::setTransmissionColour(IfcColourRgb* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcColourRgb* IfcSurfaceStyleLighting::ReflectanceColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcSurfaceStyleLighting::setReflectanceColour(IfcColourRgb* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcSurfaceStyleLighting::declaration() const { return *IfcSurfaceStyleLighting_type; } Type::Enum IfcSurfaceStyleLighting::Class() { return Type::IfcSurfaceStyleLighting; } -IfcSurfaceStyleLighting::IfcSurfaceStyleLighting(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSurfaceStyleLighting)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceStyleLighting::IfcSurfaceStyleLighting(IfcColourRgb* v1_DiffuseTransmissionColour, IfcColourRgb* v2_DiffuseReflectionColour, IfcColourRgb* v3_TransmissionColour, IfcColourRgb* v4_ReflectanceColour) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DiffuseTransmissionColour)); e->setArgument(1,(v2_DiffuseReflectionColour)); e->setArgument(2,(v3_TransmissionColour)); e->setArgument(3,(v4_ReflectanceColour)); entity = e; EntityBuffer::Add(this); } +IfcSurfaceStyleLighting::IfcSurfaceStyleLighting(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSurfaceStyleLighting)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceStyleLighting::IfcSurfaceStyleLighting(IfcColourRgb* v1_DiffuseTransmissionColour, IfcColourRgb* v2_DiffuseReflectionColour, IfcColourRgb* v3_TransmissionColour, IfcColourRgb* v4_ReflectanceColour) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_DiffuseTransmissionColour)); e->setArgument(1,(v2_DiffuseReflectionColour)); e->setArgument(2,(v3_TransmissionColour)); e->setArgument(3,(v4_ReflectanceColour)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurfaceStyleRefraction -bool IfcSurfaceStyleRefraction::hasRefractionIndex() const { return !entity->getArgument(0)->isNull(); } -double IfcSurfaceStyleRefraction::RefractionIndex() const { return *entity->getArgument(0); } -void IfcSurfaceStyleRefraction::setRefractionIndex(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcSurfaceStyleRefraction::hasDispersionFactor() const { return !entity->getArgument(1)->isNull(); } -double IfcSurfaceStyleRefraction::DispersionFactor() const { return *entity->getArgument(1); } -void IfcSurfaceStyleRefraction::setDispersionFactor(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcSurfaceStyleRefraction::is(Type::Enum v) const { return v == Type::IfcSurfaceStyleRefraction; } -Type::Enum IfcSurfaceStyleRefraction::type() const { return Type::IfcSurfaceStyleRefraction; } +bool IfcSurfaceStyleRefraction::hasRefractionIndex() const { return !data_->getArgument(0)->isNull(); } +double IfcSurfaceStyleRefraction::RefractionIndex() const { return *data_->getArgument(0); } +void IfcSurfaceStyleRefraction::setRefractionIndex(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcSurfaceStyleRefraction::hasDispersionFactor() const { return !data_->getArgument(1)->isNull(); } +double IfcSurfaceStyleRefraction::DispersionFactor() const { return *data_->getArgument(1); } +void IfcSurfaceStyleRefraction::setDispersionFactor(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcSurfaceStyleRefraction::declaration() const { return *IfcSurfaceStyleRefraction_type; } Type::Enum IfcSurfaceStyleRefraction::Class() { return Type::IfcSurfaceStyleRefraction; } -IfcSurfaceStyleRefraction::IfcSurfaceStyleRefraction(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSurfaceStyleRefraction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceStyleRefraction::IfcSurfaceStyleRefraction(boost::optional< double > v1_RefractionIndex, boost::optional< double > v2_DispersionFactor) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_RefractionIndex) { e->setArgument(0,(*v1_RefractionIndex)); } else { e->setArgument(0); } if (v2_DispersionFactor) { e->setArgument(1,(*v2_DispersionFactor)); } else { e->setArgument(1); } entity = e; EntityBuffer::Add(this); } +IfcSurfaceStyleRefraction::IfcSurfaceStyleRefraction(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSurfaceStyleRefraction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceStyleRefraction::IfcSurfaceStyleRefraction(boost::optional< double > v1_RefractionIndex, boost::optional< double > v2_DispersionFactor) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_RefractionIndex) { e->setArgument(0,(*v1_RefractionIndex)); } else { e->setArgument(0); } if (v2_DispersionFactor) { e->setArgument(1,(*v2_DispersionFactor)); } else { e->setArgument(1); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurfaceStyleRendering -bool IfcSurfaceStyleRendering::hasTransparency() const { return !entity->getArgument(1)->isNull(); } -double IfcSurfaceStyleRendering::Transparency() const { return *entity->getArgument(1); } -void IfcSurfaceStyleRendering::setTransparency(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcSurfaceStyleRendering::hasDiffuseColour() const { return !entity->getArgument(2)->isNull(); } -IfcColourOrFactor* IfcSurfaceStyleRendering::DiffuseColour() const { return (IfcColourOrFactor*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcSurfaceStyleRendering::setDiffuseColour(IfcColourOrFactor* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcSurfaceStyleRendering::hasTransmissionColour() const { return !entity->getArgument(3)->isNull(); } -IfcColourOrFactor* IfcSurfaceStyleRendering::TransmissionColour() const { return (IfcColourOrFactor*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcSurfaceStyleRendering::setTransmissionColour(IfcColourOrFactor* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcSurfaceStyleRendering::hasDiffuseTransmissionColour() const { return !entity->getArgument(4)->isNull(); } -IfcColourOrFactor* IfcSurfaceStyleRendering::DiffuseTransmissionColour() const { return (IfcColourOrFactor*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcSurfaceStyleRendering::setDiffuseTransmissionColour(IfcColourOrFactor* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcSurfaceStyleRendering::hasReflectionColour() const { return !entity->getArgument(5)->isNull(); } -IfcColourOrFactor* IfcSurfaceStyleRendering::ReflectionColour() const { return (IfcColourOrFactor*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcSurfaceStyleRendering::setReflectionColour(IfcColourOrFactor* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcSurfaceStyleRendering::hasSpecularColour() const { return !entity->getArgument(6)->isNull(); } -IfcColourOrFactor* IfcSurfaceStyleRendering::SpecularColour() const { return (IfcColourOrFactor*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcSurfaceStyleRendering::setSpecularColour(IfcColourOrFactor* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcSurfaceStyleRendering::hasSpecularHighlight() const { return !entity->getArgument(7)->isNull(); } -IfcSpecularHighlightSelect* IfcSurfaceStyleRendering::SpecularHighlight() const { return (IfcSpecularHighlightSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcSurfaceStyleRendering::setSpecularHighlight(IfcSpecularHighlightSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcReflectanceMethodEnum::IfcReflectanceMethodEnum IfcSurfaceStyleRendering::ReflectanceMethod() const { return IfcReflectanceMethodEnum::FromString(*entity->getArgument(8)); } -void IfcSurfaceStyleRendering::setReflectanceMethod(IfcReflectanceMethodEnum::IfcReflectanceMethodEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcReflectanceMethodEnum::ToString(v)); } -bool IfcSurfaceStyleRendering::is(Type::Enum v) const { return v == Type::IfcSurfaceStyleRendering || IfcSurfaceStyleShading::is(v); } -Type::Enum IfcSurfaceStyleRendering::type() const { return Type::IfcSurfaceStyleRendering; } +bool IfcSurfaceStyleRendering::hasTransparency() const { return !data_->getArgument(1)->isNull(); } +double IfcSurfaceStyleRendering::Transparency() const { return *data_->getArgument(1); } +void IfcSurfaceStyleRendering::setTransparency(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcSurfaceStyleRendering::hasDiffuseColour() const { return !data_->getArgument(2)->isNull(); } +IfcColourOrFactor* IfcSurfaceStyleRendering::DiffuseColour() const { return (IfcColourOrFactor*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcSurfaceStyleRendering::setDiffuseColour(IfcColourOrFactor* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcSurfaceStyleRendering::hasTransmissionColour() const { return !data_->getArgument(3)->isNull(); } +IfcColourOrFactor* IfcSurfaceStyleRendering::TransmissionColour() const { return (IfcColourOrFactor*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcSurfaceStyleRendering::setTransmissionColour(IfcColourOrFactor* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcSurfaceStyleRendering::hasDiffuseTransmissionColour() const { return !data_->getArgument(4)->isNull(); } +IfcColourOrFactor* IfcSurfaceStyleRendering::DiffuseTransmissionColour() const { return (IfcColourOrFactor*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcSurfaceStyleRendering::setDiffuseTransmissionColour(IfcColourOrFactor* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcSurfaceStyleRendering::hasReflectionColour() const { return !data_->getArgument(5)->isNull(); } +IfcColourOrFactor* IfcSurfaceStyleRendering::ReflectionColour() const { return (IfcColourOrFactor*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcSurfaceStyleRendering::setReflectionColour(IfcColourOrFactor* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcSurfaceStyleRendering::hasSpecularColour() const { return !data_->getArgument(6)->isNull(); } +IfcColourOrFactor* IfcSurfaceStyleRendering::SpecularColour() const { return (IfcColourOrFactor*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcSurfaceStyleRendering::setSpecularColour(IfcColourOrFactor* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcSurfaceStyleRendering::hasSpecularHighlight() const { return !data_->getArgument(7)->isNull(); } +IfcSpecularHighlightSelect* IfcSurfaceStyleRendering::SpecularHighlight() const { return (IfcSpecularHighlightSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcSurfaceStyleRendering::setSpecularHighlight(IfcSpecularHighlightSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +IfcReflectanceMethodEnum::IfcReflectanceMethodEnum IfcSurfaceStyleRendering::ReflectanceMethod() const { return IfcReflectanceMethodEnum::FromString(*data_->getArgument(8)); } +void IfcSurfaceStyleRendering::setReflectanceMethod(IfcReflectanceMethodEnum::IfcReflectanceMethodEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcReflectanceMethodEnum::ToString(v)); } + + +const IfcParse::entity& IfcSurfaceStyleRendering::declaration() const { return *IfcSurfaceStyleRendering_type; } Type::Enum IfcSurfaceStyleRendering::Class() { return Type::IfcSurfaceStyleRendering; } -IfcSurfaceStyleRendering::IfcSurfaceStyleRendering(IfcAbstractEntity* e) : IfcSurfaceStyleShading((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceStyleRendering)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceStyleRendering::IfcSurfaceStyleRendering(IfcColourRgb* v1_SurfaceColour, boost::optional< double > v2_Transparency, IfcColourOrFactor* v3_DiffuseColour, IfcColourOrFactor* v4_TransmissionColour, IfcColourOrFactor* v5_DiffuseTransmissionColour, IfcColourOrFactor* v6_ReflectionColour, IfcColourOrFactor* v7_SpecularColour, IfcSpecularHighlightSelect* v8_SpecularHighlight, IfcReflectanceMethodEnum::IfcReflectanceMethodEnum v9_ReflectanceMethod) : IfcSurfaceStyleShading((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SurfaceColour)); if (v2_Transparency) { e->setArgument(1,(*v2_Transparency)); } else { e->setArgument(1); } e->setArgument(2,(v3_DiffuseColour)); e->setArgument(3,(v4_TransmissionColour)); e->setArgument(4,(v5_DiffuseTransmissionColour)); e->setArgument(5,(v6_ReflectionColour)); e->setArgument(6,(v7_SpecularColour)); e->setArgument(7,(v8_SpecularHighlight)); e->setArgument(8,v9_ReflectanceMethod,IfcReflectanceMethodEnum::ToString(v9_ReflectanceMethod)); entity = e; EntityBuffer::Add(this); } +IfcSurfaceStyleRendering::IfcSurfaceStyleRendering(IfcAbstractEntity* e) : IfcSurfaceStyleShading((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceStyleRendering)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceStyleRendering::IfcSurfaceStyleRendering(IfcColourRgb* v1_SurfaceColour, boost::optional< double > v2_Transparency, IfcColourOrFactor* v3_DiffuseColour, IfcColourOrFactor* v4_TransmissionColour, IfcColourOrFactor* v5_DiffuseTransmissionColour, IfcColourOrFactor* v6_ReflectionColour, IfcColourOrFactor* v7_SpecularColour, IfcSpecularHighlightSelect* v8_SpecularHighlight, IfcReflectanceMethodEnum::IfcReflectanceMethodEnum v9_ReflectanceMethod) : IfcSurfaceStyleShading((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SurfaceColour)); if (v2_Transparency) { e->setArgument(1,(*v2_Transparency)); } else { e->setArgument(1); } e->setArgument(2,(v3_DiffuseColour)); e->setArgument(3,(v4_TransmissionColour)); e->setArgument(4,(v5_DiffuseTransmissionColour)); e->setArgument(5,(v6_ReflectionColour)); e->setArgument(6,(v7_SpecularColour)); e->setArgument(7,(v8_SpecularHighlight)); e->setArgument(8,v9_ReflectanceMethod,IfcReflectanceMethodEnum::ToString(v9_ReflectanceMethod)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurfaceStyleShading -IfcColourRgb* IfcSurfaceStyleShading::SurfaceColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcSurfaceStyleShading::setSurfaceColour(IfcColourRgb* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcSurfaceStyleShading::is(Type::Enum v) const { return v == Type::IfcSurfaceStyleShading; } -Type::Enum IfcSurfaceStyleShading::type() const { return Type::IfcSurfaceStyleShading; } +IfcColourRgb* IfcSurfaceStyleShading::SurfaceColour() const { return (IfcColourRgb*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcSurfaceStyleShading::setSurfaceColour(IfcColourRgb* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcSurfaceStyleShading::declaration() const { return *IfcSurfaceStyleShading_type; } Type::Enum IfcSurfaceStyleShading::Class() { return Type::IfcSurfaceStyleShading; } -IfcSurfaceStyleShading::IfcSurfaceStyleShading(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSurfaceStyleShading)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceStyleShading::IfcSurfaceStyleShading(IfcColourRgb* v1_SurfaceColour) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SurfaceColour)); entity = e; EntityBuffer::Add(this); } +IfcSurfaceStyleShading::IfcSurfaceStyleShading(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSurfaceStyleShading)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceStyleShading::IfcSurfaceStyleShading(IfcColourRgb* v1_SurfaceColour) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SurfaceColour)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurfaceStyleWithTextures -IfcTemplatedEntityList< IfcSurfaceTexture >::ptr IfcSurfaceStyleWithTextures::Textures() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcSurfaceStyleWithTextures::setTextures(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcSurfaceStyleWithTextures::is(Type::Enum v) const { return v == Type::IfcSurfaceStyleWithTextures; } -Type::Enum IfcSurfaceStyleWithTextures::type() const { return Type::IfcSurfaceStyleWithTextures; } +IfcTemplatedEntityList< IfcSurfaceTexture >::ptr IfcSurfaceStyleWithTextures::Textures() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcSurfaceStyleWithTextures::setTextures(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcSurfaceStyleWithTextures::declaration() const { return *IfcSurfaceStyleWithTextures_type; } Type::Enum IfcSurfaceStyleWithTextures::Class() { return Type::IfcSurfaceStyleWithTextures; } -IfcSurfaceStyleWithTextures::IfcSurfaceStyleWithTextures(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSurfaceStyleWithTextures)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceStyleWithTextures::IfcSurfaceStyleWithTextures(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Textures) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Textures)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcSurfaceStyleWithTextures::IfcSurfaceStyleWithTextures(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSurfaceStyleWithTextures)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceStyleWithTextures::IfcSurfaceStyleWithTextures(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Textures) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Textures)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurfaceTexture -bool IfcSurfaceTexture::RepeatS() const { return *entity->getArgument(0); } -void IfcSurfaceTexture::setRepeatS(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcSurfaceTexture::RepeatT() const { return *entity->getArgument(1); } -void IfcSurfaceTexture::setRepeatT(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcSurfaceTextureEnum::IfcSurfaceTextureEnum IfcSurfaceTexture::TextureType() const { return IfcSurfaceTextureEnum::FromString(*entity->getArgument(2)); } -void IfcSurfaceTexture::setTextureType(IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v,IfcSurfaceTextureEnum::ToString(v)); } -bool IfcSurfaceTexture::hasTextureTransform() const { return !entity->getArgument(3)->isNull(); } -IfcCartesianTransformationOperator2D* IfcSurfaceTexture::TextureTransform() const { return (IfcCartesianTransformationOperator2D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcSurfaceTexture::setTextureTransform(IfcCartesianTransformationOperator2D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcSurfaceTexture::is(Type::Enum v) const { return v == Type::IfcSurfaceTexture; } -Type::Enum IfcSurfaceTexture::type() const { return Type::IfcSurfaceTexture; } +bool IfcSurfaceTexture::RepeatS() const { return *data_->getArgument(0); } +void IfcSurfaceTexture::setRepeatS(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcSurfaceTexture::RepeatT() const { return *data_->getArgument(1); } +void IfcSurfaceTexture::setRepeatT(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcSurfaceTextureEnum::IfcSurfaceTextureEnum IfcSurfaceTexture::TextureType() const { return IfcSurfaceTextureEnum::FromString(*data_->getArgument(2)); } +void IfcSurfaceTexture::setTextureType(IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v,IfcSurfaceTextureEnum::ToString(v)); } +bool IfcSurfaceTexture::hasTextureTransform() const { return !data_->getArgument(3)->isNull(); } +IfcCartesianTransformationOperator2D* IfcSurfaceTexture::TextureTransform() const { return (IfcCartesianTransformationOperator2D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcSurfaceTexture::setTextureTransform(IfcCartesianTransformationOperator2D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcSurfaceTexture::declaration() const { return *IfcSurfaceTexture_type; } Type::Enum IfcSurfaceTexture::Class() { return Type::IfcSurfaceTexture; } -IfcSurfaceTexture::IfcSurfaceTexture(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSurfaceTexture)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceTexture::IfcSurfaceTexture(bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); e->setArgument(2,v3_TextureType,IfcSurfaceTextureEnum::ToString(v3_TextureType)); e->setArgument(3,(v4_TextureTransform)); entity = e; EntityBuffer::Add(this); } +IfcSurfaceTexture::IfcSurfaceTexture(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSurfaceTexture)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceTexture::IfcSurfaceTexture(bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); e->setArgument(2,v3_TextureType,IfcSurfaceTextureEnum::ToString(v3_TextureType)); e->setArgument(3,(v4_TextureTransform)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSweptAreaSolid -IfcProfileDef* IfcSweptAreaSolid::SweptArea() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcSweptAreaSolid::setSweptArea(IfcProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcAxis2Placement3D* IfcSweptAreaSolid::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcSweptAreaSolid::setPosition(IfcAxis2Placement3D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcSweptAreaSolid::is(Type::Enum v) const { return v == Type::IfcSweptAreaSolid || IfcSolidModel::is(v); } -Type::Enum IfcSweptAreaSolid::type() const { return Type::IfcSweptAreaSolid; } +IfcProfileDef* IfcSweptAreaSolid::SweptArea() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcSweptAreaSolid::setSweptArea(IfcProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcAxis2Placement3D* IfcSweptAreaSolid::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcSweptAreaSolid::setPosition(IfcAxis2Placement3D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcSweptAreaSolid::declaration() const { return *IfcSweptAreaSolid_type; } Type::Enum IfcSweptAreaSolid::Class() { return Type::IfcSweptAreaSolid; } -IfcSweptAreaSolid::IfcSweptAreaSolid(IfcAbstractEntity* e) : IfcSolidModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSweptAreaSolid)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSweptAreaSolid::IfcSweptAreaSolid(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position) : IfcSolidModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptArea)); e->setArgument(1,(v2_Position)); entity = e; EntityBuffer::Add(this); } +IfcSweptAreaSolid::IfcSweptAreaSolid(IfcAbstractEntity* e) : IfcSolidModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSweptAreaSolid)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSweptAreaSolid::IfcSweptAreaSolid(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position) : IfcSolidModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptArea)); e->setArgument(1,(v2_Position)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSweptDiskSolid -IfcCurve* IfcSweptDiskSolid::Directrix() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcSweptDiskSolid::setDirectrix(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcSweptDiskSolid::Radius() const { return *entity->getArgument(1); } -void IfcSweptDiskSolid::setRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcSweptDiskSolid::hasInnerRadius() const { return !entity->getArgument(2)->isNull(); } -double IfcSweptDiskSolid::InnerRadius() const { return *entity->getArgument(2); } -void IfcSweptDiskSolid::setInnerRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -double IfcSweptDiskSolid::StartParam() const { return *entity->getArgument(3); } -void IfcSweptDiskSolid::setStartParam(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcSweptDiskSolid::EndParam() const { return *entity->getArgument(4); } -void IfcSweptDiskSolid::setEndParam(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcSweptDiskSolid::is(Type::Enum v) const { return v == Type::IfcSweptDiskSolid || IfcSolidModel::is(v); } -Type::Enum IfcSweptDiskSolid::type() const { return Type::IfcSweptDiskSolid; } +IfcCurve* IfcSweptDiskSolid::Directrix() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcSweptDiskSolid::setDirectrix(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcSweptDiskSolid::Radius() const { return *data_->getArgument(1); } +void IfcSweptDiskSolid::setRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcSweptDiskSolid::hasInnerRadius() const { return !data_->getArgument(2)->isNull(); } +double IfcSweptDiskSolid::InnerRadius() const { return *data_->getArgument(2); } +void IfcSweptDiskSolid::setInnerRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +double IfcSweptDiskSolid::StartParam() const { return *data_->getArgument(3); } +void IfcSweptDiskSolid::setStartParam(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcSweptDiskSolid::EndParam() const { return *data_->getArgument(4); } +void IfcSweptDiskSolid::setEndParam(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcSweptDiskSolid::declaration() const { return *IfcSweptDiskSolid_type; } Type::Enum IfcSweptDiskSolid::Class() { return Type::IfcSweptDiskSolid; } -IfcSweptDiskSolid::IfcSweptDiskSolid(IfcAbstractEntity* e) : IfcSolidModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSweptDiskSolid)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSweptDiskSolid::IfcSweptDiskSolid(IfcCurve* v1_Directrix, double v2_Radius, boost::optional< double > v3_InnerRadius, double v4_StartParam, double v5_EndParam) : IfcSolidModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Directrix)); e->setArgument(1,(v2_Radius)); if (v3_InnerRadius) { e->setArgument(2,(*v3_InnerRadius)); } else { e->setArgument(2); } e->setArgument(3,(v4_StartParam)); e->setArgument(4,(v5_EndParam)); entity = e; EntityBuffer::Add(this); } +IfcSweptDiskSolid::IfcSweptDiskSolid(IfcAbstractEntity* e) : IfcSolidModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSweptDiskSolid)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSweptDiskSolid::IfcSweptDiskSolid(IfcCurve* v1_Directrix, double v2_Radius, boost::optional< double > v3_InnerRadius, double v4_StartParam, double v5_EndParam) : IfcSolidModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Directrix)); e->setArgument(1,(v2_Radius)); if (v3_InnerRadius) { e->setArgument(2,(*v3_InnerRadius)); } else { e->setArgument(2); } e->setArgument(3,(v4_StartParam)); e->setArgument(4,(v5_EndParam)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSweptSurface -IfcProfileDef* IfcSweptSurface::SweptCurve() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcSweptSurface::setSweptCurve(IfcProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcAxis2Placement3D* IfcSweptSurface::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcSweptSurface::setPosition(IfcAxis2Placement3D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcSweptSurface::is(Type::Enum v) const { return v == Type::IfcSweptSurface || IfcSurface::is(v); } -Type::Enum IfcSweptSurface::type() const { return Type::IfcSweptSurface; } +IfcProfileDef* IfcSweptSurface::SweptCurve() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcSweptSurface::setSweptCurve(IfcProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcAxis2Placement3D* IfcSweptSurface::Position() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcSweptSurface::setPosition(IfcAxis2Placement3D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcSweptSurface::declaration() const { return *IfcSweptSurface_type; } Type::Enum IfcSweptSurface::Class() { return Type::IfcSweptSurface; } -IfcSweptSurface::IfcSweptSurface(IfcAbstractEntity* e) : IfcSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSweptSurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSweptSurface::IfcSweptSurface(IfcProfileDef* v1_SweptCurve, IfcAxis2Placement3D* v2_Position) : IfcSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptCurve)); e->setArgument(1,(v2_Position)); entity = e; EntityBuffer::Add(this); } +IfcSweptSurface::IfcSweptSurface(IfcAbstractEntity* e) : IfcSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSweptSurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSweptSurface::IfcSweptSurface(IfcProfileDef* v1_SweptCurve, IfcAxis2Placement3D* v2_Position) : IfcSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptCurve)); e->setArgument(1,(v2_Position)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSwitchingDeviceType -IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum IfcSwitchingDeviceType::PredefinedType() const { return IfcSwitchingDeviceTypeEnum::FromString(*entity->getArgument(9)); } -void IfcSwitchingDeviceType::setPredefinedType(IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcSwitchingDeviceTypeEnum::ToString(v)); } -bool IfcSwitchingDeviceType::is(Type::Enum v) const { return v == Type::IfcSwitchingDeviceType || IfcFlowControllerType::is(v); } -Type::Enum IfcSwitchingDeviceType::type() const { return Type::IfcSwitchingDeviceType; } +IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum IfcSwitchingDeviceType::PredefinedType() const { return IfcSwitchingDeviceTypeEnum::FromString(*data_->getArgument(9)); } +void IfcSwitchingDeviceType::setPredefinedType(IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcSwitchingDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSwitchingDeviceType::declaration() const { return *IfcSwitchingDeviceType_type; } Type::Enum IfcSwitchingDeviceType::Class() { return Type::IfcSwitchingDeviceType; } -IfcSwitchingDeviceType::IfcSwitchingDeviceType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSwitchingDeviceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSwitchingDeviceType::IfcSwitchingDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSwitchingDeviceTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcSwitchingDeviceType::IfcSwitchingDeviceType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSwitchingDeviceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSwitchingDeviceType::IfcSwitchingDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcSwitchingDeviceTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSymbolStyle -IfcSymbolStyleSelect* IfcSymbolStyle::StyleOfSymbol() const { return (IfcSymbolStyleSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcSymbolStyle::setStyleOfSymbol(IfcSymbolStyleSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcSymbolStyle::is(Type::Enum v) const { return v == Type::IfcSymbolStyle || IfcPresentationStyle::is(v); } -Type::Enum IfcSymbolStyle::type() const { return Type::IfcSymbolStyle; } +IfcSymbolStyleSelect* IfcSymbolStyle::StyleOfSymbol() const { return (IfcSymbolStyleSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcSymbolStyle::setStyleOfSymbol(IfcSymbolStyleSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcSymbolStyle::declaration() const { return *IfcSymbolStyle_type; } Type::Enum IfcSymbolStyle::Class() { return Type::IfcSymbolStyle; } -IfcSymbolStyle::IfcSymbolStyle(IfcAbstractEntity* e) : IfcPresentationStyle((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSymbolStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSymbolStyle::IfcSymbolStyle(boost::optional< std::string > v1_Name, IfcSymbolStyleSelect* v2_StyleOfSymbol) : IfcPresentationStyle((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_StyleOfSymbol)); entity = e; EntityBuffer::Add(this); } +IfcSymbolStyle::IfcSymbolStyle(IfcAbstractEntity* e) : IfcPresentationStyle((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSymbolStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSymbolStyle::IfcSymbolStyle(boost::optional< std::string > v1_Name, IfcSymbolStyleSelect* v2_StyleOfSymbol) : IfcPresentationStyle((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_StyleOfSymbol)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSystem -IfcRelServicesBuildings::list::ptr IfcSystem::ServicesBuildings() const { return entity->getInverse(Type::IfcRelServicesBuildings, 4)->as(); } -bool IfcSystem::is(Type::Enum v) const { return v == Type::IfcSystem || IfcGroup::is(v); } -Type::Enum IfcSystem::type() const { return Type::IfcSystem; } + +IfcRelServicesBuildings::list::ptr IfcSystem::ServicesBuildings() const { return data_->getInverse(Type::IfcRelServicesBuildings, 4)->as(); } + +const IfcParse::entity& IfcSystem::declaration() const { return *IfcSystem_type; } Type::Enum IfcSystem::Class() { return Type::IfcSystem; } -IfcSystem::IfcSystem(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSystem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSystem::IfcSystem(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcSystem::IfcSystem(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSystem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSystem::IfcSystem(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSystemFurnitureElementType -bool IfcSystemFurnitureElementType::is(Type::Enum v) const { return v == Type::IfcSystemFurnitureElementType || IfcFurnishingElementType::is(v); } -Type::Enum IfcSystemFurnitureElementType::type() const { return Type::IfcSystemFurnitureElementType; } + + +const IfcParse::entity& IfcSystemFurnitureElementType::declaration() const { return *IfcSystemFurnitureElementType_type; } Type::Enum IfcSystemFurnitureElementType::Class() { return Type::IfcSystemFurnitureElementType; } -IfcSystemFurnitureElementType::IfcSystemFurnitureElementType(IfcAbstractEntity* e) : IfcFurnishingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSystemFurnitureElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSystemFurnitureElementType::IfcSystemFurnitureElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcFurnishingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSystemFurnitureElementType::IfcSystemFurnitureElementType(IfcAbstractEntity* e) : IfcFurnishingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSystemFurnitureElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSystemFurnitureElementType::IfcSystemFurnitureElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcFurnishingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTShapeProfileDef -double IfcTShapeProfileDef::Depth() const { return *entity->getArgument(3); } -void IfcTShapeProfileDef::setDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcTShapeProfileDef::FlangeWidth() const { return *entity->getArgument(4); } -void IfcTShapeProfileDef::setFlangeWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -double IfcTShapeProfileDef::WebThickness() const { return *entity->getArgument(5); } -void IfcTShapeProfileDef::setWebThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcTShapeProfileDef::FlangeThickness() const { return *entity->getArgument(6); } -void IfcTShapeProfileDef::setFlangeThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcTShapeProfileDef::hasFilletRadius() const { return !entity->getArgument(7)->isNull(); } -double IfcTShapeProfileDef::FilletRadius() const { return *entity->getArgument(7); } -void IfcTShapeProfileDef::setFilletRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcTShapeProfileDef::hasFlangeEdgeRadius() const { return !entity->getArgument(8)->isNull(); } -double IfcTShapeProfileDef::FlangeEdgeRadius() const { return *entity->getArgument(8); } -void IfcTShapeProfileDef::setFlangeEdgeRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcTShapeProfileDef::hasWebEdgeRadius() const { return !entity->getArgument(9)->isNull(); } -double IfcTShapeProfileDef::WebEdgeRadius() const { return *entity->getArgument(9); } -void IfcTShapeProfileDef::setWebEdgeRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcTShapeProfileDef::hasWebSlope() const { return !entity->getArgument(10)->isNull(); } -double IfcTShapeProfileDef::WebSlope() const { return *entity->getArgument(10); } -void IfcTShapeProfileDef::setWebSlope(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcTShapeProfileDef::hasFlangeSlope() const { return !entity->getArgument(11)->isNull(); } -double IfcTShapeProfileDef::FlangeSlope() const { return *entity->getArgument(11); } -void IfcTShapeProfileDef::setFlangeSlope(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcTShapeProfileDef::hasCentreOfGravityInY() const { return !entity->getArgument(12)->isNull(); } -double IfcTShapeProfileDef::CentreOfGravityInY() const { return *entity->getArgument(12); } -void IfcTShapeProfileDef::setCentreOfGravityInY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcTShapeProfileDef::is(Type::Enum v) const { return v == Type::IfcTShapeProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcTShapeProfileDef::type() const { return Type::IfcTShapeProfileDef; } +double IfcTShapeProfileDef::Depth() const { return *data_->getArgument(3); } +void IfcTShapeProfileDef::setDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcTShapeProfileDef::FlangeWidth() const { return *data_->getArgument(4); } +void IfcTShapeProfileDef::setFlangeWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +double IfcTShapeProfileDef::WebThickness() const { return *data_->getArgument(5); } +void IfcTShapeProfileDef::setWebThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcTShapeProfileDef::FlangeThickness() const { return *data_->getArgument(6); } +void IfcTShapeProfileDef::setFlangeThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcTShapeProfileDef::hasFilletRadius() const { return !data_->getArgument(7)->isNull(); } +double IfcTShapeProfileDef::FilletRadius() const { return *data_->getArgument(7); } +void IfcTShapeProfileDef::setFilletRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcTShapeProfileDef::hasFlangeEdgeRadius() const { return !data_->getArgument(8)->isNull(); } +double IfcTShapeProfileDef::FlangeEdgeRadius() const { return *data_->getArgument(8); } +void IfcTShapeProfileDef::setFlangeEdgeRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcTShapeProfileDef::hasWebEdgeRadius() const { return !data_->getArgument(9)->isNull(); } +double IfcTShapeProfileDef::WebEdgeRadius() const { return *data_->getArgument(9); } +void IfcTShapeProfileDef::setWebEdgeRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcTShapeProfileDef::hasWebSlope() const { return !data_->getArgument(10)->isNull(); } +double IfcTShapeProfileDef::WebSlope() const { return *data_->getArgument(10); } +void IfcTShapeProfileDef::setWebSlope(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcTShapeProfileDef::hasFlangeSlope() const { return !data_->getArgument(11)->isNull(); } +double IfcTShapeProfileDef::FlangeSlope() const { return *data_->getArgument(11); } +void IfcTShapeProfileDef::setFlangeSlope(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcTShapeProfileDef::hasCentreOfGravityInY() const { return !data_->getArgument(12)->isNull(); } +double IfcTShapeProfileDef::CentreOfGravityInY() const { return *data_->getArgument(12); } +void IfcTShapeProfileDef::setCentreOfGravityInY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } + + +const IfcParse::entity& IfcTShapeProfileDef::declaration() const { return *IfcTShapeProfileDef_type; } Type::Enum IfcTShapeProfileDef::Class() { return Type::IfcTShapeProfileDef; } -IfcTShapeProfileDef::IfcTShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTShapeProfileDef::IfcTShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_FlangeEdgeRadius, boost::optional< double > v10_WebEdgeRadius, boost::optional< double > v11_WebSlope, boost::optional< double > v12_FlangeSlope, boost::optional< double > v13_CentreOfGravityInY) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Depth)); e->setArgument(4,(v5_FlangeWidth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_FlangeThickness)); if (v8_FilletRadius) { e->setArgument(7,(*v8_FilletRadius)); } else { e->setArgument(7); } if (v9_FlangeEdgeRadius) { e->setArgument(8,(*v9_FlangeEdgeRadius)); } else { e->setArgument(8); } if (v10_WebEdgeRadius) { e->setArgument(9,(*v10_WebEdgeRadius)); } else { e->setArgument(9); } if (v11_WebSlope) { e->setArgument(10,(*v11_WebSlope)); } else { e->setArgument(10); } if (v12_FlangeSlope) { e->setArgument(11,(*v12_FlangeSlope)); } else { e->setArgument(11); } if (v13_CentreOfGravityInY) { e->setArgument(12,(*v13_CentreOfGravityInY)); } else { e->setArgument(12); } entity = e; EntityBuffer::Add(this); } +IfcTShapeProfileDef::IfcTShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTShapeProfileDef::IfcTShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_FlangeEdgeRadius, boost::optional< double > v10_WebEdgeRadius, boost::optional< double > v11_WebSlope, boost::optional< double > v12_FlangeSlope, boost::optional< double > v13_CentreOfGravityInY) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Depth)); e->setArgument(4,(v5_FlangeWidth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_FlangeThickness)); if (v8_FilletRadius) { e->setArgument(7,(*v8_FilletRadius)); } else { e->setArgument(7); } if (v9_FlangeEdgeRadius) { e->setArgument(8,(*v9_FlangeEdgeRadius)); } else { e->setArgument(8); } if (v10_WebEdgeRadius) { e->setArgument(9,(*v10_WebEdgeRadius)); } else { e->setArgument(9); } if (v11_WebSlope) { e->setArgument(10,(*v11_WebSlope)); } else { e->setArgument(10); } if (v12_FlangeSlope) { e->setArgument(11,(*v12_FlangeSlope)); } else { e->setArgument(11); } if (v13_CentreOfGravityInY) { e->setArgument(12,(*v13_CentreOfGravityInY)); } else { e->setArgument(12); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTable -std::string IfcTable::Name() const { return *entity->getArgument(0); } -void IfcTable::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcTemplatedEntityList< IfcTableRow >::ptr IfcTable::Rows() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcTable::setRows(IfcTemplatedEntityList< IfcTableRow >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcTable::is(Type::Enum v) const { return v == Type::IfcTable; } -Type::Enum IfcTable::type() const { return Type::IfcTable; } +std::string IfcTable::Name() const { return *data_->getArgument(0); } +void IfcTable::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcTemplatedEntityList< IfcTableRow >::ptr IfcTable::Rows() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcTable::setRows(IfcTemplatedEntityList< IfcTableRow >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } + + +const IfcParse::entity& IfcTable::declaration() const { return *IfcTable_type; } Type::Enum IfcTable::Class() { return Type::IfcTable; } -IfcTable::IfcTable(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTable)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTable::IfcTable(std::string v1_Name, IfcTemplatedEntityList< IfcTableRow >::ptr v2_Rows) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); e->setArgument(1,(v2_Rows)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcTable::IfcTable(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTable)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTable::IfcTable(std::string v1_Name, IfcTemplatedEntityList< IfcTableRow >::ptr v2_Rows) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); e->setArgument(1,(v2_Rows)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTableRow -IfcEntityList::ptr IfcTableRow::RowCells() const { return *entity->getArgument(0); } -void IfcTableRow::setRowCells(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcTableRow::IsHeading() const { return *entity->getArgument(1); } -void IfcTableRow::setIsHeading(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcTable::list::ptr IfcTableRow::OfTable() const { return entity->getInverse(Type::IfcTable, 1)->as(); } -bool IfcTableRow::is(Type::Enum v) const { return v == Type::IfcTableRow; } -Type::Enum IfcTableRow::type() const { return Type::IfcTableRow; } +IfcEntityList::ptr IfcTableRow::RowCells() const { return *data_->getArgument(0); } +void IfcTableRow::setRowCells(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcTableRow::IsHeading() const { return *data_->getArgument(1); } +void IfcTableRow::setIsHeading(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + +IfcTable::list::ptr IfcTableRow::OfTable() const { return data_->getInverse(Type::IfcTable, 1)->as(); } + +const IfcParse::entity& IfcTableRow::declaration() const { return *IfcTableRow_type; } Type::Enum IfcTableRow::Class() { return Type::IfcTableRow; } -IfcTableRow::IfcTableRow(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTableRow)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTableRow::IfcTableRow(IfcEntityList::ptr v1_RowCells, bool v2_IsHeading) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RowCells)); e->setArgument(1,(v2_IsHeading)); entity = e; EntityBuffer::Add(this); } +IfcTableRow::IfcTableRow(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTableRow)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTableRow::IfcTableRow(IfcEntityList::ptr v1_RowCells, bool v2_IsHeading) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RowCells)); e->setArgument(1,(v2_IsHeading)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTankType -IfcTankTypeEnum::IfcTankTypeEnum IfcTankType::PredefinedType() const { return IfcTankTypeEnum::FromString(*entity->getArgument(9)); } -void IfcTankType::setPredefinedType(IfcTankTypeEnum::IfcTankTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcTankTypeEnum::ToString(v)); } -bool IfcTankType::is(Type::Enum v) const { return v == Type::IfcTankType || IfcFlowStorageDeviceType::is(v); } -Type::Enum IfcTankType::type() const { return Type::IfcTankType; } +IfcTankTypeEnum::IfcTankTypeEnum IfcTankType::PredefinedType() const { return IfcTankTypeEnum::FromString(*data_->getArgument(9)); } +void IfcTankType::setPredefinedType(IfcTankTypeEnum::IfcTankTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcTankTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcTankType::declaration() const { return *IfcTankType_type; } Type::Enum IfcTankType::Class() { return Type::IfcTankType; } -IfcTankType::IfcTankType(IfcAbstractEntity* e) : IfcFlowStorageDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTankType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTankType::IfcTankType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTankTypeEnum::IfcTankTypeEnum v10_PredefinedType) : IfcFlowStorageDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTankTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcTankType::IfcTankType(IfcAbstractEntity* e) : IfcFlowStorageDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTankType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTankType::IfcTankType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTankTypeEnum::IfcTankTypeEnum v10_PredefinedType) : IfcFlowStorageDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTankTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTask -std::string IfcTask::TaskId() const { return *entity->getArgument(5); } -void IfcTask::setTaskId(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcTask::hasStatus() const { return !entity->getArgument(6)->isNull(); } -std::string IfcTask::Status() const { return *entity->getArgument(6); } -void IfcTask::setStatus(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcTask::hasWorkMethod() const { return !entity->getArgument(7)->isNull(); } -std::string IfcTask::WorkMethod() const { return *entity->getArgument(7); } -void IfcTask::setWorkMethod(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcTask::IsMilestone() const { return *entity->getArgument(8); } -void IfcTask::setIsMilestone(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcTask::hasPriority() const { return !entity->getArgument(9)->isNull(); } -int IfcTask::Priority() const { return *entity->getArgument(9); } -void IfcTask::setPriority(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcTask::is(Type::Enum v) const { return v == Type::IfcTask || IfcProcess::is(v); } -Type::Enum IfcTask::type() const { return Type::IfcTask; } +std::string IfcTask::TaskId() const { return *data_->getArgument(5); } +void IfcTask::setTaskId(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcTask::hasStatus() const { return !data_->getArgument(6)->isNull(); } +std::string IfcTask::Status() const { return *data_->getArgument(6); } +void IfcTask::setStatus(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcTask::hasWorkMethod() const { return !data_->getArgument(7)->isNull(); } +std::string IfcTask::WorkMethod() const { return *data_->getArgument(7); } +void IfcTask::setWorkMethod(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcTask::IsMilestone() const { return *data_->getArgument(8); } +void IfcTask::setIsMilestone(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcTask::hasPriority() const { return !data_->getArgument(9)->isNull(); } +int IfcTask::Priority() const { return *data_->getArgument(9); } +void IfcTask::setPriority(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcTask::declaration() const { return *IfcTask_type; } Type::Enum IfcTask::Class() { return Type::IfcTask; } -IfcTask::IfcTask(IfcAbstractEntity* e) : IfcProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTask)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTask::IfcTask(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority) : IfcProcess((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_TaskId)); if (v7_Status) { e->setArgument(6,(*v7_Status)); } else { e->setArgument(6); } if (v8_WorkMethod) { e->setArgument(7,(*v8_WorkMethod)); } else { e->setArgument(7); } e->setArgument(8,(v9_IsMilestone)); if (v10_Priority) { e->setArgument(9,(*v10_Priority)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcTask::IfcTask(IfcAbstractEntity* e) : IfcProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTask)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTask::IfcTask(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority) : IfcProcess((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_TaskId)); if (v7_Status) { e->setArgument(6,(*v7_Status)); } else { e->setArgument(6); } if (v8_WorkMethod) { e->setArgument(7,(*v8_WorkMethod)); } else { e->setArgument(7); } e->setArgument(8,(v9_IsMilestone)); if (v10_Priority) { e->setArgument(9,(*v10_Priority)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTelecomAddress -bool IfcTelecomAddress::hasTelephoneNumbers() const { return !entity->getArgument(3)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcTelecomAddress::TelephoneNumbers() const { return *entity->getArgument(3); } -void IfcTelecomAddress::setTelephoneNumbers(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcTelecomAddress::hasFacsimileNumbers() const { return !entity->getArgument(4)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcTelecomAddress::FacsimileNumbers() const { return *entity->getArgument(4); } -void IfcTelecomAddress::setFacsimileNumbers(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcTelecomAddress::hasPagerNumber() const { return !entity->getArgument(5)->isNull(); } -std::string IfcTelecomAddress::PagerNumber() const { return *entity->getArgument(5); } -void IfcTelecomAddress::setPagerNumber(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcTelecomAddress::hasElectronicMailAddresses() const { return !entity->getArgument(6)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcTelecomAddress::ElectronicMailAddresses() const { return *entity->getArgument(6); } -void IfcTelecomAddress::setElectronicMailAddresses(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcTelecomAddress::hasWWWHomePageURL() const { return !entity->getArgument(7)->isNull(); } -std::string IfcTelecomAddress::WWWHomePageURL() const { return *entity->getArgument(7); } -void IfcTelecomAddress::setWWWHomePageURL(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcTelecomAddress::is(Type::Enum v) const { return v == Type::IfcTelecomAddress || IfcAddress::is(v); } -Type::Enum IfcTelecomAddress::type() const { return Type::IfcTelecomAddress; } +bool IfcTelecomAddress::hasTelephoneNumbers() const { return !data_->getArgument(3)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcTelecomAddress::TelephoneNumbers() const { return *data_->getArgument(3); } +void IfcTelecomAddress::setTelephoneNumbers(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcTelecomAddress::hasFacsimileNumbers() const { return !data_->getArgument(4)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcTelecomAddress::FacsimileNumbers() const { return *data_->getArgument(4); } +void IfcTelecomAddress::setFacsimileNumbers(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcTelecomAddress::hasPagerNumber() const { return !data_->getArgument(5)->isNull(); } +std::string IfcTelecomAddress::PagerNumber() const { return *data_->getArgument(5); } +void IfcTelecomAddress::setPagerNumber(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcTelecomAddress::hasElectronicMailAddresses() const { return !data_->getArgument(6)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcTelecomAddress::ElectronicMailAddresses() const { return *data_->getArgument(6); } +void IfcTelecomAddress::setElectronicMailAddresses(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcTelecomAddress::hasWWWHomePageURL() const { return !data_->getArgument(7)->isNull(); } +std::string IfcTelecomAddress::WWWHomePageURL() const { return *data_->getArgument(7); } +void IfcTelecomAddress::setWWWHomePageURL(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcTelecomAddress::declaration() const { return *IfcTelecomAddress_type; } Type::Enum IfcTelecomAddress::Class() { return Type::IfcTelecomAddress; } -IfcTelecomAddress::IfcTelecomAddress(IfcAbstractEntity* e) : IfcAddress((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTelecomAddress)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTelecomAddress::IfcTelecomAddress(boost::optional< IfcAddressTypeEnum::IfcAddressTypeEnum > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose, boost::optional< std::vector< std::string > /*[1:?]*/ > v4_TelephoneNumbers, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_FacsimileNumbers, boost::optional< std::string > v6_PagerNumber, boost::optional< std::vector< std::string > /*[1:?]*/ > v7_ElectronicMailAddresses, boost::optional< std::string > v8_WWWHomePageURL) : IfcAddress((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Purpose) { e->setArgument(0,*v1_Purpose,IfcAddressTypeEnum::ToString(*v1_Purpose)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } if (v3_UserDefinedPurpose) { e->setArgument(2,(*v3_UserDefinedPurpose)); } else { e->setArgument(2); } if (v4_TelephoneNumbers) { e->setArgument(3,(*v4_TelephoneNumbers)); } else { e->setArgument(3); } if (v5_FacsimileNumbers) { e->setArgument(4,(*v5_FacsimileNumbers)); } else { e->setArgument(4); } if (v6_PagerNumber) { e->setArgument(5,(*v6_PagerNumber)); } else { e->setArgument(5); } if (v7_ElectronicMailAddresses) { e->setArgument(6,(*v7_ElectronicMailAddresses)); } else { e->setArgument(6); } if (v8_WWWHomePageURL) { e->setArgument(7,(*v8_WWWHomePageURL)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcTelecomAddress::IfcTelecomAddress(IfcAbstractEntity* e) : IfcAddress((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTelecomAddress)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTelecomAddress::IfcTelecomAddress(boost::optional< IfcAddressTypeEnum::IfcAddressTypeEnum > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose, boost::optional< std::vector< std::string > /*[1:?]*/ > v4_TelephoneNumbers, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_FacsimileNumbers, boost::optional< std::string > v6_PagerNumber, boost::optional< std::vector< std::string > /*[1:?]*/ > v7_ElectronicMailAddresses, boost::optional< std::string > v8_WWWHomePageURL) : IfcAddress((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Purpose) { e->setArgument(0,*v1_Purpose,IfcAddressTypeEnum::ToString(*v1_Purpose)); } else { e->setArgument(0); } if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } if (v3_UserDefinedPurpose) { e->setArgument(2,(*v3_UserDefinedPurpose)); } else { e->setArgument(2); } if (v4_TelephoneNumbers) { e->setArgument(3,(*v4_TelephoneNumbers)); } else { e->setArgument(3); } if (v5_FacsimileNumbers) { e->setArgument(4,(*v5_FacsimileNumbers)); } else { e->setArgument(4); } if (v6_PagerNumber) { e->setArgument(5,(*v6_PagerNumber)); } else { e->setArgument(5); } if (v7_ElectronicMailAddresses) { e->setArgument(6,(*v7_ElectronicMailAddresses)); } else { e->setArgument(6); } if (v8_WWWHomePageURL) { e->setArgument(7,(*v8_WWWHomePageURL)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTendon -IfcTendonTypeEnum::IfcTendonTypeEnum IfcTendon::PredefinedType() const { return IfcTendonTypeEnum::FromString(*entity->getArgument(9)); } -void IfcTendon::setPredefinedType(IfcTendonTypeEnum::IfcTendonTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcTendonTypeEnum::ToString(v)); } -double IfcTendon::NominalDiameter() const { return *entity->getArgument(10); } -void IfcTendon::setNominalDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -double IfcTendon::CrossSectionArea() const { return *entity->getArgument(11); } -void IfcTendon::setCrossSectionArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcTendon::hasTensionForce() const { return !entity->getArgument(12)->isNull(); } -double IfcTendon::TensionForce() const { return *entity->getArgument(12); } -void IfcTendon::setTensionForce(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcTendon::hasPreStress() const { return !entity->getArgument(13)->isNull(); } -double IfcTendon::PreStress() const { return *entity->getArgument(13); } -void IfcTendon::setPreStress(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcTendon::hasFrictionCoefficient() const { return !entity->getArgument(14)->isNull(); } -double IfcTendon::FrictionCoefficient() const { return *entity->getArgument(14); } -void IfcTendon::setFrictionCoefficient(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcTendon::hasAnchorageSlip() const { return !entity->getArgument(15)->isNull(); } -double IfcTendon::AnchorageSlip() const { return *entity->getArgument(15); } -void IfcTendon::setAnchorageSlip(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v); } -bool IfcTendon::hasMinCurvatureRadius() const { return !entity->getArgument(16)->isNull(); } -double IfcTendon::MinCurvatureRadius() const { return *entity->getArgument(16); } -void IfcTendon::setMinCurvatureRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(16,v); } -bool IfcTendon::is(Type::Enum v) const { return v == Type::IfcTendon || IfcReinforcingElement::is(v); } -Type::Enum IfcTendon::type() const { return Type::IfcTendon; } +IfcTendonTypeEnum::IfcTendonTypeEnum IfcTendon::PredefinedType() const { return IfcTendonTypeEnum::FromString(*data_->getArgument(9)); } +void IfcTendon::setPredefinedType(IfcTendonTypeEnum::IfcTendonTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcTendonTypeEnum::ToString(v)); } +double IfcTendon::NominalDiameter() const { return *data_->getArgument(10); } +void IfcTendon::setNominalDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +double IfcTendon::CrossSectionArea() const { return *data_->getArgument(11); } +void IfcTendon::setCrossSectionArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcTendon::hasTensionForce() const { return !data_->getArgument(12)->isNull(); } +double IfcTendon::TensionForce() const { return *data_->getArgument(12); } +void IfcTendon::setTensionForce(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcTendon::hasPreStress() const { return !data_->getArgument(13)->isNull(); } +double IfcTendon::PreStress() const { return *data_->getArgument(13); } +void IfcTendon::setPreStress(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcTendon::hasFrictionCoefficient() const { return !data_->getArgument(14)->isNull(); } +double IfcTendon::FrictionCoefficient() const { return *data_->getArgument(14); } +void IfcTendon::setFrictionCoefficient(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } +bool IfcTendon::hasAnchorageSlip() const { return !data_->getArgument(15)->isNull(); } +double IfcTendon::AnchorageSlip() const { return *data_->getArgument(15); } +void IfcTendon::setAnchorageSlip(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v); } +bool IfcTendon::hasMinCurvatureRadius() const { return !data_->getArgument(16)->isNull(); } +double IfcTendon::MinCurvatureRadius() const { return *data_->getArgument(16); } +void IfcTendon::setMinCurvatureRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(16,v); } + + +const IfcParse::entity& IfcTendon::declaration() const { return *IfcTendon_type; } Type::Enum IfcTendon::Class() { return Type::IfcTendon; } -IfcTendon::IfcTendon(IfcAbstractEntity* e) : IfcReinforcingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTendon)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTendon::IfcTendon(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, IfcTendonTypeEnum::IfcTendonTypeEnum v10_PredefinedType, double v11_NominalDiameter, double v12_CrossSectionArea, boost::optional< double > v13_TensionForce, boost::optional< double > v14_PreStress, boost::optional< double > v15_FrictionCoefficient, boost::optional< double > v16_AnchorageSlip, boost::optional< double > v17_MinCurvatureRadius) : IfcReinforcingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTendonTypeEnum::ToString(v10_PredefinedType)); e->setArgument(10,(v11_NominalDiameter)); e->setArgument(11,(v12_CrossSectionArea)); if (v13_TensionForce) { e->setArgument(12,(*v13_TensionForce)); } else { e->setArgument(12); } if (v14_PreStress) { e->setArgument(13,(*v14_PreStress)); } else { e->setArgument(13); } if (v15_FrictionCoefficient) { e->setArgument(14,(*v15_FrictionCoefficient)); } else { e->setArgument(14); } if (v16_AnchorageSlip) { e->setArgument(15,(*v16_AnchorageSlip)); } else { e->setArgument(15); } if (v17_MinCurvatureRadius) { e->setArgument(16,(*v17_MinCurvatureRadius)); } else { e->setArgument(16); } entity = e; EntityBuffer::Add(this); } +IfcTendon::IfcTendon(IfcAbstractEntity* e) : IfcReinforcingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTendon)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTendon::IfcTendon(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, IfcTendonTypeEnum::IfcTendonTypeEnum v10_PredefinedType, double v11_NominalDiameter, double v12_CrossSectionArea, boost::optional< double > v13_TensionForce, boost::optional< double > v14_PreStress, boost::optional< double > v15_FrictionCoefficient, boost::optional< double > v16_AnchorageSlip, boost::optional< double > v17_MinCurvatureRadius) : IfcReinforcingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTendonTypeEnum::ToString(v10_PredefinedType)); e->setArgument(10,(v11_NominalDiameter)); e->setArgument(11,(v12_CrossSectionArea)); if (v13_TensionForce) { e->setArgument(12,(*v13_TensionForce)); } else { e->setArgument(12); } if (v14_PreStress) { e->setArgument(13,(*v14_PreStress)); } else { e->setArgument(13); } if (v15_FrictionCoefficient) { e->setArgument(14,(*v15_FrictionCoefficient)); } else { e->setArgument(14); } if (v16_AnchorageSlip) { e->setArgument(15,(*v16_AnchorageSlip)); } else { e->setArgument(15); } if (v17_MinCurvatureRadius) { e->setArgument(16,(*v17_MinCurvatureRadius)); } else { e->setArgument(16); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTendonAnchor -bool IfcTendonAnchor::is(Type::Enum v) const { return v == Type::IfcTendonAnchor || IfcReinforcingElement::is(v); } -Type::Enum IfcTendonAnchor::type() const { return Type::IfcTendonAnchor; } + + +const IfcParse::entity& IfcTendonAnchor::declaration() const { return *IfcTendonAnchor_type; } Type::Enum IfcTendonAnchor::Class() { return Type::IfcTendonAnchor; } -IfcTendonAnchor::IfcTendonAnchor(IfcAbstractEntity* e) : IfcReinforcingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTendonAnchor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTendonAnchor::IfcTendonAnchor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade) : IfcReinforcingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcTendonAnchor::IfcTendonAnchor(IfcAbstractEntity* e) : IfcReinforcingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTendonAnchor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTendonAnchor::IfcTendonAnchor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade) : IfcReinforcingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTerminatorSymbol -IfcAnnotationCurveOccurrence* IfcTerminatorSymbol::AnnotatedCurve() const { return (IfcAnnotationCurveOccurrence*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcTerminatorSymbol::setAnnotatedCurve(IfcAnnotationCurveOccurrence* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcTerminatorSymbol::is(Type::Enum v) const { return v == Type::IfcTerminatorSymbol || IfcAnnotationSymbolOccurrence::is(v); } -Type::Enum IfcTerminatorSymbol::type() const { return Type::IfcTerminatorSymbol; } +IfcAnnotationCurveOccurrence* IfcTerminatorSymbol::AnnotatedCurve() const { return (IfcAnnotationCurveOccurrence*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcTerminatorSymbol::setAnnotatedCurve(IfcAnnotationCurveOccurrence* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcTerminatorSymbol::declaration() const { return *IfcTerminatorSymbol_type; } Type::Enum IfcTerminatorSymbol::Class() { return Type::IfcTerminatorSymbol; } -IfcTerminatorSymbol::IfcTerminatorSymbol(IfcAbstractEntity* e) : IfcAnnotationSymbolOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTerminatorSymbol)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTerminatorSymbol::IfcTerminatorSymbol(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, IfcAnnotationCurveOccurrence* v4_AnnotatedCurve) : IfcAnnotationSymbolOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } e->setArgument(3,(v4_AnnotatedCurve)); entity = e; EntityBuffer::Add(this); } +IfcTerminatorSymbol::IfcTerminatorSymbol(IfcAbstractEntity* e) : IfcAnnotationSymbolOccurrence((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTerminatorSymbol)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTerminatorSymbol::IfcTerminatorSymbol(IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, IfcAnnotationCurveOccurrence* v4_AnnotatedCurve) : IfcAnnotationSymbolOccurrence((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Item)); e->setArgument(1,(v2_Styles)->generalize()); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } e->setArgument(3,(v4_AnnotatedCurve)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextLiteral -std::string IfcTextLiteral::Literal() const { return *entity->getArgument(0); } -void IfcTextLiteral::setLiteral(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcAxis2Placement* IfcTextLiteral::Placement() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcTextLiteral::setPlacement(IfcAxis2Placement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcTextPath::IfcTextPath IfcTextLiteral::Path() const { return IfcTextPath::FromString(*entity->getArgument(2)); } -void IfcTextLiteral::setPath(IfcTextPath::IfcTextPath v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v,IfcTextPath::ToString(v)); } -bool IfcTextLiteral::is(Type::Enum v) const { return v == Type::IfcTextLiteral || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcTextLiteral::type() const { return Type::IfcTextLiteral; } +std::string IfcTextLiteral::Literal() const { return *data_->getArgument(0); } +void IfcTextLiteral::setLiteral(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcAxis2Placement* IfcTextLiteral::Placement() const { return (IfcAxis2Placement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcTextLiteral::setPlacement(IfcAxis2Placement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcTextPath::IfcTextPath IfcTextLiteral::Path() const { return IfcTextPath::FromString(*data_->getArgument(2)); } +void IfcTextLiteral::setPath(IfcTextPath::IfcTextPath v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v,IfcTextPath::ToString(v)); } + + +const IfcParse::entity& IfcTextLiteral::declaration() const { return *IfcTextLiteral_type; } Type::Enum IfcTextLiteral::Class() { return Type::IfcTextLiteral; } -IfcTextLiteral::IfcTextLiteral(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextLiteral)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextLiteral::IfcTextLiteral(std::string v1_Literal, IfcAxis2Placement* v2_Placement, IfcTextPath::IfcTextPath v3_Path) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Literal)); e->setArgument(1,(v2_Placement)); e->setArgument(2,v3_Path,IfcTextPath::ToString(v3_Path)); entity = e; EntityBuffer::Add(this); } +IfcTextLiteral::IfcTextLiteral(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextLiteral)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextLiteral::IfcTextLiteral(std::string v1_Literal, IfcAxis2Placement* v2_Placement, IfcTextPath::IfcTextPath v3_Path) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Literal)); e->setArgument(1,(v2_Placement)); e->setArgument(2,v3_Path,IfcTextPath::ToString(v3_Path)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextLiteralWithExtent -IfcPlanarExtent* IfcTextLiteralWithExtent::Extent() const { return (IfcPlanarExtent*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcTextLiteralWithExtent::setExtent(IfcPlanarExtent* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -std::string IfcTextLiteralWithExtent::BoxAlignment() const { return *entity->getArgument(4); } -void IfcTextLiteralWithExtent::setBoxAlignment(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcTextLiteralWithExtent::is(Type::Enum v) const { return v == Type::IfcTextLiteralWithExtent || IfcTextLiteral::is(v); } -Type::Enum IfcTextLiteralWithExtent::type() const { return Type::IfcTextLiteralWithExtent; } +IfcPlanarExtent* IfcTextLiteralWithExtent::Extent() const { return (IfcPlanarExtent*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcTextLiteralWithExtent::setExtent(IfcPlanarExtent* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +std::string IfcTextLiteralWithExtent::BoxAlignment() const { return *data_->getArgument(4); } +void IfcTextLiteralWithExtent::setBoxAlignment(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcTextLiteralWithExtent::declaration() const { return *IfcTextLiteralWithExtent_type; } Type::Enum IfcTextLiteralWithExtent::Class() { return Type::IfcTextLiteralWithExtent; } -IfcTextLiteralWithExtent::IfcTextLiteralWithExtent(IfcAbstractEntity* e) : IfcTextLiteral((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextLiteralWithExtent)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextLiteralWithExtent::IfcTextLiteralWithExtent(std::string v1_Literal, IfcAxis2Placement* v2_Placement, IfcTextPath::IfcTextPath v3_Path, IfcPlanarExtent* v4_Extent, std::string v5_BoxAlignment) : IfcTextLiteral((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Literal)); e->setArgument(1,(v2_Placement)); e->setArgument(2,v3_Path,IfcTextPath::ToString(v3_Path)); e->setArgument(3,(v4_Extent)); e->setArgument(4,(v5_BoxAlignment)); entity = e; EntityBuffer::Add(this); } +IfcTextLiteralWithExtent::IfcTextLiteralWithExtent(IfcAbstractEntity* e) : IfcTextLiteral((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextLiteralWithExtent)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextLiteralWithExtent::IfcTextLiteralWithExtent(std::string v1_Literal, IfcAxis2Placement* v2_Placement, IfcTextPath::IfcTextPath v3_Path, IfcPlanarExtent* v4_Extent, std::string v5_BoxAlignment) : IfcTextLiteral((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Literal)); e->setArgument(1,(v2_Placement)); e->setArgument(2,v3_Path,IfcTextPath::ToString(v3_Path)); e->setArgument(3,(v4_Extent)); e->setArgument(4,(v5_BoxAlignment)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextStyle -bool IfcTextStyle::hasTextCharacterAppearance() const { return !entity->getArgument(1)->isNull(); } -IfcCharacterStyleSelect* IfcTextStyle::TextCharacterAppearance() const { return (IfcCharacterStyleSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcTextStyle::setTextCharacterAppearance(IfcCharacterStyleSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTextStyle::hasTextStyle() const { return !entity->getArgument(2)->isNull(); } -IfcTextStyleSelect* IfcTextStyle::TextStyle() const { return (IfcTextStyleSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcTextStyle::setTextStyle(IfcTextStyleSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcTextFontSelect* IfcTextStyle::TextFontStyle() const { return (IfcTextFontSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcTextStyle::setTextFontStyle(IfcTextFontSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcTextStyle::is(Type::Enum v) const { return v == Type::IfcTextStyle || IfcPresentationStyle::is(v); } -Type::Enum IfcTextStyle::type() const { return Type::IfcTextStyle; } +bool IfcTextStyle::hasTextCharacterAppearance() const { return !data_->getArgument(1)->isNull(); } +IfcCharacterStyleSelect* IfcTextStyle::TextCharacterAppearance() const { return (IfcCharacterStyleSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcTextStyle::setTextCharacterAppearance(IfcCharacterStyleSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcTextStyle::hasTextStyle() const { return !data_->getArgument(2)->isNull(); } +IfcTextStyleSelect* IfcTextStyle::TextStyle() const { return (IfcTextStyleSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcTextStyle::setTextStyle(IfcTextStyleSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcTextFontSelect* IfcTextStyle::TextFontStyle() const { return (IfcTextFontSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcTextStyle::setTextFontStyle(IfcTextFontSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcTextStyle::declaration() const { return *IfcTextStyle_type; } Type::Enum IfcTextStyle::Class() { return Type::IfcTextStyle; } -IfcTextStyle::IfcTextStyle(IfcAbstractEntity* e) : IfcPresentationStyle((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextStyle::IfcTextStyle(boost::optional< std::string > v1_Name, IfcCharacterStyleSelect* v2_TextCharacterAppearance, IfcTextStyleSelect* v3_TextStyle, IfcTextFontSelect* v4_TextFontStyle) : IfcPresentationStyle((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_TextCharacterAppearance)); e->setArgument(2,(v3_TextStyle)); e->setArgument(3,(v4_TextFontStyle)); entity = e; EntityBuffer::Add(this); } +IfcTextStyle::IfcTextStyle(IfcAbstractEntity* e) : IfcPresentationStyle((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextStyle::IfcTextStyle(boost::optional< std::string > v1_Name, IfcCharacterStyleSelect* v2_TextCharacterAppearance, IfcTextStyleSelect* v3_TextStyle, IfcTextFontSelect* v4_TextFontStyle) : IfcPresentationStyle((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_TextCharacterAppearance)); e->setArgument(2,(v3_TextStyle)); e->setArgument(3,(v4_TextFontStyle)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextStyleFontModel -bool IfcTextStyleFontModel::hasFontFamily() const { return !entity->getArgument(1)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcTextStyleFontModel::FontFamily() const { return *entity->getArgument(1); } -void IfcTextStyleFontModel::setFontFamily(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTextStyleFontModel::hasFontStyle() const { return !entity->getArgument(2)->isNull(); } -std::string IfcTextStyleFontModel::FontStyle() const { return *entity->getArgument(2); } -void IfcTextStyleFontModel::setFontStyle(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcTextStyleFontModel::hasFontVariant() const { return !entity->getArgument(3)->isNull(); } -std::string IfcTextStyleFontModel::FontVariant() const { return *entity->getArgument(3); } -void IfcTextStyleFontModel::setFontVariant(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcTextStyleFontModel::hasFontWeight() const { return !entity->getArgument(4)->isNull(); } -std::string IfcTextStyleFontModel::FontWeight() const { return *entity->getArgument(4); } -void IfcTextStyleFontModel::setFontWeight(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcSizeSelect* IfcTextStyleFontModel::FontSize() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcTextStyleFontModel::setFontSize(IfcSizeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcTextStyleFontModel::is(Type::Enum v) const { return v == Type::IfcTextStyleFontModel || IfcPreDefinedTextFont::is(v); } -Type::Enum IfcTextStyleFontModel::type() const { return Type::IfcTextStyleFontModel; } +bool IfcTextStyleFontModel::hasFontFamily() const { return !data_->getArgument(1)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcTextStyleFontModel::FontFamily() const { return *data_->getArgument(1); } +void IfcTextStyleFontModel::setFontFamily(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcTextStyleFontModel::hasFontStyle() const { return !data_->getArgument(2)->isNull(); } +std::string IfcTextStyleFontModel::FontStyle() const { return *data_->getArgument(2); } +void IfcTextStyleFontModel::setFontStyle(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcTextStyleFontModel::hasFontVariant() const { return !data_->getArgument(3)->isNull(); } +std::string IfcTextStyleFontModel::FontVariant() const { return *data_->getArgument(3); } +void IfcTextStyleFontModel::setFontVariant(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcTextStyleFontModel::hasFontWeight() const { return !data_->getArgument(4)->isNull(); } +std::string IfcTextStyleFontModel::FontWeight() const { return *data_->getArgument(4); } +void IfcTextStyleFontModel::setFontWeight(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcSizeSelect* IfcTextStyleFontModel::FontSize() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcTextStyleFontModel::setFontSize(IfcSizeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcTextStyleFontModel::declaration() const { return *IfcTextStyleFontModel_type; } Type::Enum IfcTextStyleFontModel::Class() { return Type::IfcTextStyleFontModel; } -IfcTextStyleFontModel::IfcTextStyleFontModel(IfcAbstractEntity* e) : IfcPreDefinedTextFont((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextStyleFontModel)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextStyleFontModel::IfcTextStyleFontModel(std::string v1_Name, boost::optional< std::vector< std::string > /*[1:?]*/ > v2_FontFamily, boost::optional< std::string > v3_FontStyle, boost::optional< std::string > v4_FontVariant, boost::optional< std::string > v5_FontWeight, IfcSizeSelect* v6_FontSize) : IfcPreDefinedTextFont((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_FontFamily) { e->setArgument(1,(*v2_FontFamily)); } else { e->setArgument(1); } if (v3_FontStyle) { e->setArgument(2,(*v3_FontStyle)); } else { e->setArgument(2); } if (v4_FontVariant) { e->setArgument(3,(*v4_FontVariant)); } else { e->setArgument(3); } if (v5_FontWeight) { e->setArgument(4,(*v5_FontWeight)); } else { e->setArgument(4); } e->setArgument(5,(v6_FontSize)); entity = e; EntityBuffer::Add(this); } +IfcTextStyleFontModel::IfcTextStyleFontModel(IfcAbstractEntity* e) : IfcPreDefinedTextFont((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextStyleFontModel)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextStyleFontModel::IfcTextStyleFontModel(std::string v1_Name, boost::optional< std::vector< std::string > /*[1:?]*/ > v2_FontFamily, boost::optional< std::string > v3_FontStyle, boost::optional< std::string > v4_FontVariant, boost::optional< std::string > v5_FontWeight, IfcSizeSelect* v6_FontSize) : IfcPreDefinedTextFont((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_FontFamily) { e->setArgument(1,(*v2_FontFamily)); } else { e->setArgument(1); } if (v3_FontStyle) { e->setArgument(2,(*v3_FontStyle)); } else { e->setArgument(2); } if (v4_FontVariant) { e->setArgument(3,(*v4_FontVariant)); } else { e->setArgument(3); } if (v5_FontWeight) { e->setArgument(4,(*v5_FontWeight)); } else { e->setArgument(4); } e->setArgument(5,(v6_FontSize)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextStyleForDefinedFont -IfcColour* IfcTextStyleForDefinedFont::Colour() const { return (IfcColour*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcTextStyleForDefinedFont::setColour(IfcColour* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcTextStyleForDefinedFont::hasBackgroundColour() const { return !entity->getArgument(1)->isNull(); } -IfcColour* IfcTextStyleForDefinedFont::BackgroundColour() const { return (IfcColour*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcTextStyleForDefinedFont::setBackgroundColour(IfcColour* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTextStyleForDefinedFont::is(Type::Enum v) const { return v == Type::IfcTextStyleForDefinedFont; } -Type::Enum IfcTextStyleForDefinedFont::type() const { return Type::IfcTextStyleForDefinedFont; } +IfcColour* IfcTextStyleForDefinedFont::Colour() const { return (IfcColour*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcTextStyleForDefinedFont::setColour(IfcColour* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcTextStyleForDefinedFont::hasBackgroundColour() const { return !data_->getArgument(1)->isNull(); } +IfcColour* IfcTextStyleForDefinedFont::BackgroundColour() const { return (IfcColour*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcTextStyleForDefinedFont::setBackgroundColour(IfcColour* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcTextStyleForDefinedFont::declaration() const { return *IfcTextStyleForDefinedFont_type; } Type::Enum IfcTextStyleForDefinedFont::Class() { return Type::IfcTextStyleForDefinedFont; } -IfcTextStyleForDefinedFont::IfcTextStyleForDefinedFont(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTextStyleForDefinedFont)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextStyleForDefinedFont::IfcTextStyleForDefinedFont(IfcColour* v1_Colour, IfcColour* v2_BackgroundColour) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Colour)); e->setArgument(1,(v2_BackgroundColour)); entity = e; EntityBuffer::Add(this); } +IfcTextStyleForDefinedFont::IfcTextStyleForDefinedFont(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTextStyleForDefinedFont)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextStyleForDefinedFont::IfcTextStyleForDefinedFont(IfcColour* v1_Colour, IfcColour* v2_BackgroundColour) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Colour)); e->setArgument(1,(v2_BackgroundColour)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextStyleTextModel -bool IfcTextStyleTextModel::hasTextIndent() const { return !entity->getArgument(0)->isNull(); } -IfcSizeSelect* IfcTextStyleTextModel::TextIndent() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcTextStyleTextModel::setTextIndent(IfcSizeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcTextStyleTextModel::hasTextAlign() const { return !entity->getArgument(1)->isNull(); } -std::string IfcTextStyleTextModel::TextAlign() const { return *entity->getArgument(1); } -void IfcTextStyleTextModel::setTextAlign(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTextStyleTextModel::hasTextDecoration() const { return !entity->getArgument(2)->isNull(); } -std::string IfcTextStyleTextModel::TextDecoration() const { return *entity->getArgument(2); } -void IfcTextStyleTextModel::setTextDecoration(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcTextStyleTextModel::hasLetterSpacing() const { return !entity->getArgument(3)->isNull(); } -IfcSizeSelect* IfcTextStyleTextModel::LetterSpacing() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcTextStyleTextModel::setLetterSpacing(IfcSizeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcTextStyleTextModel::hasWordSpacing() const { return !entity->getArgument(4)->isNull(); } -IfcSizeSelect* IfcTextStyleTextModel::WordSpacing() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcTextStyleTextModel::setWordSpacing(IfcSizeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcTextStyleTextModel::hasTextTransform() const { return !entity->getArgument(5)->isNull(); } -std::string IfcTextStyleTextModel::TextTransform() const { return *entity->getArgument(5); } -void IfcTextStyleTextModel::setTextTransform(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcTextStyleTextModel::hasLineHeight() const { return !entity->getArgument(6)->isNull(); } -IfcSizeSelect* IfcTextStyleTextModel::LineHeight() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcTextStyleTextModel::setLineHeight(IfcSizeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcTextStyleTextModel::is(Type::Enum v) const { return v == Type::IfcTextStyleTextModel; } -Type::Enum IfcTextStyleTextModel::type() const { return Type::IfcTextStyleTextModel; } +bool IfcTextStyleTextModel::hasTextIndent() const { return !data_->getArgument(0)->isNull(); } +IfcSizeSelect* IfcTextStyleTextModel::TextIndent() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcTextStyleTextModel::setTextIndent(IfcSizeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcTextStyleTextModel::hasTextAlign() const { return !data_->getArgument(1)->isNull(); } +std::string IfcTextStyleTextModel::TextAlign() const { return *data_->getArgument(1); } +void IfcTextStyleTextModel::setTextAlign(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcTextStyleTextModel::hasTextDecoration() const { return !data_->getArgument(2)->isNull(); } +std::string IfcTextStyleTextModel::TextDecoration() const { return *data_->getArgument(2); } +void IfcTextStyleTextModel::setTextDecoration(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcTextStyleTextModel::hasLetterSpacing() const { return !data_->getArgument(3)->isNull(); } +IfcSizeSelect* IfcTextStyleTextModel::LetterSpacing() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcTextStyleTextModel::setLetterSpacing(IfcSizeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcTextStyleTextModel::hasWordSpacing() const { return !data_->getArgument(4)->isNull(); } +IfcSizeSelect* IfcTextStyleTextModel::WordSpacing() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcTextStyleTextModel::setWordSpacing(IfcSizeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcTextStyleTextModel::hasTextTransform() const { return !data_->getArgument(5)->isNull(); } +std::string IfcTextStyleTextModel::TextTransform() const { return *data_->getArgument(5); } +void IfcTextStyleTextModel::setTextTransform(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcTextStyleTextModel::hasLineHeight() const { return !data_->getArgument(6)->isNull(); } +IfcSizeSelect* IfcTextStyleTextModel::LineHeight() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcTextStyleTextModel::setLineHeight(IfcSizeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcTextStyleTextModel::declaration() const { return *IfcTextStyleTextModel_type; } Type::Enum IfcTextStyleTextModel::Class() { return Type::IfcTextStyleTextModel; } -IfcTextStyleTextModel::IfcTextStyleTextModel(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTextStyleTextModel)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextStyleTextModel::IfcTextStyleTextModel(IfcSizeSelect* v1_TextIndent, boost::optional< std::string > v2_TextAlign, boost::optional< std::string > v3_TextDecoration, IfcSizeSelect* v4_LetterSpacing, IfcSizeSelect* v5_WordSpacing, boost::optional< std::string > v6_TextTransform, IfcSizeSelect* v7_LineHeight) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TextIndent)); if (v2_TextAlign) { e->setArgument(1,(*v2_TextAlign)); } else { e->setArgument(1); } if (v3_TextDecoration) { e->setArgument(2,(*v3_TextDecoration)); } else { e->setArgument(2); } e->setArgument(3,(v4_LetterSpacing)); e->setArgument(4,(v5_WordSpacing)); if (v6_TextTransform) { e->setArgument(5,(*v6_TextTransform)); } else { e->setArgument(5); } e->setArgument(6,(v7_LineHeight)); entity = e; EntityBuffer::Add(this); } +IfcTextStyleTextModel::IfcTextStyleTextModel(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTextStyleTextModel)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextStyleTextModel::IfcTextStyleTextModel(IfcSizeSelect* v1_TextIndent, boost::optional< std::string > v2_TextAlign, boost::optional< std::string > v3_TextDecoration, IfcSizeSelect* v4_LetterSpacing, IfcSizeSelect* v5_WordSpacing, boost::optional< std::string > v6_TextTransform, IfcSizeSelect* v7_LineHeight) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TextIndent)); if (v2_TextAlign) { e->setArgument(1,(*v2_TextAlign)); } else { e->setArgument(1); } if (v3_TextDecoration) { e->setArgument(2,(*v3_TextDecoration)); } else { e->setArgument(2); } e->setArgument(3,(v4_LetterSpacing)); e->setArgument(4,(v5_WordSpacing)); if (v6_TextTransform) { e->setArgument(5,(*v6_TextTransform)); } else { e->setArgument(5); } e->setArgument(6,(v7_LineHeight)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextStyleWithBoxCharacteristics -bool IfcTextStyleWithBoxCharacteristics::hasBoxHeight() const { return !entity->getArgument(0)->isNull(); } -double IfcTextStyleWithBoxCharacteristics::BoxHeight() const { return *entity->getArgument(0); } -void IfcTextStyleWithBoxCharacteristics::setBoxHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcTextStyleWithBoxCharacteristics::hasBoxWidth() const { return !entity->getArgument(1)->isNull(); } -double IfcTextStyleWithBoxCharacteristics::BoxWidth() const { return *entity->getArgument(1); } -void IfcTextStyleWithBoxCharacteristics::setBoxWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTextStyleWithBoxCharacteristics::hasBoxSlantAngle() const { return !entity->getArgument(2)->isNull(); } -double IfcTextStyleWithBoxCharacteristics::BoxSlantAngle() const { return *entity->getArgument(2); } -void IfcTextStyleWithBoxCharacteristics::setBoxSlantAngle(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcTextStyleWithBoxCharacteristics::hasBoxRotateAngle() const { return !entity->getArgument(3)->isNull(); } -double IfcTextStyleWithBoxCharacteristics::BoxRotateAngle() const { return *entity->getArgument(3); } -void IfcTextStyleWithBoxCharacteristics::setBoxRotateAngle(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcTextStyleWithBoxCharacteristics::hasCharacterSpacing() const { return !entity->getArgument(4)->isNull(); } -IfcSizeSelect* IfcTextStyleWithBoxCharacteristics::CharacterSpacing() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcTextStyleWithBoxCharacteristics::setCharacterSpacing(IfcSizeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcTextStyleWithBoxCharacteristics::is(Type::Enum v) const { return v == Type::IfcTextStyleWithBoxCharacteristics; } -Type::Enum IfcTextStyleWithBoxCharacteristics::type() const { return Type::IfcTextStyleWithBoxCharacteristics; } +bool IfcTextStyleWithBoxCharacteristics::hasBoxHeight() const { return !data_->getArgument(0)->isNull(); } +double IfcTextStyleWithBoxCharacteristics::BoxHeight() const { return *data_->getArgument(0); } +void IfcTextStyleWithBoxCharacteristics::setBoxHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcTextStyleWithBoxCharacteristics::hasBoxWidth() const { return !data_->getArgument(1)->isNull(); } +double IfcTextStyleWithBoxCharacteristics::BoxWidth() const { return *data_->getArgument(1); } +void IfcTextStyleWithBoxCharacteristics::setBoxWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcTextStyleWithBoxCharacteristics::hasBoxSlantAngle() const { return !data_->getArgument(2)->isNull(); } +double IfcTextStyleWithBoxCharacteristics::BoxSlantAngle() const { return *data_->getArgument(2); } +void IfcTextStyleWithBoxCharacteristics::setBoxSlantAngle(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcTextStyleWithBoxCharacteristics::hasBoxRotateAngle() const { return !data_->getArgument(3)->isNull(); } +double IfcTextStyleWithBoxCharacteristics::BoxRotateAngle() const { return *data_->getArgument(3); } +void IfcTextStyleWithBoxCharacteristics::setBoxRotateAngle(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcTextStyleWithBoxCharacteristics::hasCharacterSpacing() const { return !data_->getArgument(4)->isNull(); } +IfcSizeSelect* IfcTextStyleWithBoxCharacteristics::CharacterSpacing() const { return (IfcSizeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcTextStyleWithBoxCharacteristics::setCharacterSpacing(IfcSizeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcTextStyleWithBoxCharacteristics::declaration() const { return *IfcTextStyleWithBoxCharacteristics_type; } Type::Enum IfcTextStyleWithBoxCharacteristics::Class() { return Type::IfcTextStyleWithBoxCharacteristics; } -IfcTextStyleWithBoxCharacteristics::IfcTextStyleWithBoxCharacteristics(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTextStyleWithBoxCharacteristics)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextStyleWithBoxCharacteristics::IfcTextStyleWithBoxCharacteristics(boost::optional< double > v1_BoxHeight, boost::optional< double > v2_BoxWidth, boost::optional< double > v3_BoxSlantAngle, boost::optional< double > v4_BoxRotateAngle, IfcSizeSelect* v5_CharacterSpacing) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_BoxHeight) { e->setArgument(0,(*v1_BoxHeight)); } else { e->setArgument(0); } if (v2_BoxWidth) { e->setArgument(1,(*v2_BoxWidth)); } else { e->setArgument(1); } if (v3_BoxSlantAngle) { e->setArgument(2,(*v3_BoxSlantAngle)); } else { e->setArgument(2); } if (v4_BoxRotateAngle) { e->setArgument(3,(*v4_BoxRotateAngle)); } else { e->setArgument(3); } e->setArgument(4,(v5_CharacterSpacing)); entity = e; EntityBuffer::Add(this); } +IfcTextStyleWithBoxCharacteristics::IfcTextStyleWithBoxCharacteristics(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTextStyleWithBoxCharacteristics)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextStyleWithBoxCharacteristics::IfcTextStyleWithBoxCharacteristics(boost::optional< double > v1_BoxHeight, boost::optional< double > v2_BoxWidth, boost::optional< double > v3_BoxSlantAngle, boost::optional< double > v4_BoxRotateAngle, IfcSizeSelect* v5_CharacterSpacing) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_BoxHeight) { e->setArgument(0,(*v1_BoxHeight)); } else { e->setArgument(0); } if (v2_BoxWidth) { e->setArgument(1,(*v2_BoxWidth)); } else { e->setArgument(1); } if (v3_BoxSlantAngle) { e->setArgument(2,(*v3_BoxSlantAngle)); } else { e->setArgument(2); } if (v4_BoxRotateAngle) { e->setArgument(3,(*v4_BoxRotateAngle)); } else { e->setArgument(3); } e->setArgument(4,(v5_CharacterSpacing)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextureCoordinate -IfcAnnotationSurface::list::ptr IfcTextureCoordinate::AnnotatedSurface() const { return entity->getInverse(Type::IfcAnnotationSurface, 1)->as(); } -bool IfcTextureCoordinate::is(Type::Enum v) const { return v == Type::IfcTextureCoordinate; } -Type::Enum IfcTextureCoordinate::type() const { return Type::IfcTextureCoordinate; } + +IfcAnnotationSurface::list::ptr IfcTextureCoordinate::AnnotatedSurface() const { return data_->getInverse(Type::IfcAnnotationSurface, 1)->as(); } + +const IfcParse::entity& IfcTextureCoordinate::declaration() const { return *IfcTextureCoordinate_type; } Type::Enum IfcTextureCoordinate::Class() { return Type::IfcTextureCoordinate; } -IfcTextureCoordinate::IfcTextureCoordinate(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTextureCoordinate)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextureCoordinate::IfcTextureCoordinate() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcTextureCoordinate::IfcTextureCoordinate(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTextureCoordinate)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextureCoordinate::IfcTextureCoordinate() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextureCoordinateGenerator -std::string IfcTextureCoordinateGenerator::Mode() const { return *entity->getArgument(0); } -void IfcTextureCoordinateGenerator::setMode(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcEntityList::ptr IfcTextureCoordinateGenerator::Parameter() const { return *entity->getArgument(1); } -void IfcTextureCoordinateGenerator::setParameter(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTextureCoordinateGenerator::is(Type::Enum v) const { return v == Type::IfcTextureCoordinateGenerator || IfcTextureCoordinate::is(v); } -Type::Enum IfcTextureCoordinateGenerator::type() const { return Type::IfcTextureCoordinateGenerator; } +std::string IfcTextureCoordinateGenerator::Mode() const { return *data_->getArgument(0); } +void IfcTextureCoordinateGenerator::setMode(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcEntityList::ptr IfcTextureCoordinateGenerator::Parameter() const { return *data_->getArgument(1); } +void IfcTextureCoordinateGenerator::setParameter(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcTextureCoordinateGenerator::declaration() const { return *IfcTextureCoordinateGenerator_type; } Type::Enum IfcTextureCoordinateGenerator::Class() { return Type::IfcTextureCoordinateGenerator; } -IfcTextureCoordinateGenerator::IfcTextureCoordinateGenerator(IfcAbstractEntity* e) : IfcTextureCoordinate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextureCoordinateGenerator)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextureCoordinateGenerator::IfcTextureCoordinateGenerator(std::string v1_Mode, IfcEntityList::ptr v2_Parameter) : IfcTextureCoordinate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Mode)); e->setArgument(1,(v2_Parameter)); entity = e; EntityBuffer::Add(this); } +IfcTextureCoordinateGenerator::IfcTextureCoordinateGenerator(IfcAbstractEntity* e) : IfcTextureCoordinate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextureCoordinateGenerator)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextureCoordinateGenerator::IfcTextureCoordinateGenerator(std::string v1_Mode, IfcEntityList::ptr v2_Parameter) : IfcTextureCoordinate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Mode)); e->setArgument(1,(v2_Parameter)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextureMap -IfcTemplatedEntityList< IfcVertexBasedTextureMap >::ptr IfcTextureMap::TextureMaps() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcTextureMap::setTextureMaps(IfcTemplatedEntityList< IfcVertexBasedTextureMap >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcTextureMap::is(Type::Enum v) const { return v == Type::IfcTextureMap || IfcTextureCoordinate::is(v); } -Type::Enum IfcTextureMap::type() const { return Type::IfcTextureMap; } +IfcTemplatedEntityList< IfcVertexBasedTextureMap >::ptr IfcTextureMap::TextureMaps() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcTextureMap::setTextureMaps(IfcTemplatedEntityList< IfcVertexBasedTextureMap >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcTextureMap::declaration() const { return *IfcTextureMap_type; } Type::Enum IfcTextureMap::Class() { return Type::IfcTextureMap; } -IfcTextureMap::IfcTextureMap(IfcAbstractEntity* e) : IfcTextureCoordinate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextureMap)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextureMap::IfcTextureMap(IfcTemplatedEntityList< IfcVertexBasedTextureMap >::ptr v1_TextureMaps) : IfcTextureCoordinate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TextureMaps)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcTextureMap::IfcTextureMap(IfcAbstractEntity* e) : IfcTextureCoordinate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextureMap)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextureMap::IfcTextureMap(IfcTemplatedEntityList< IfcVertexBasedTextureMap >::ptr v1_TextureMaps) : IfcTextureCoordinate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TextureMaps)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextureVertex -std::vector< double > /*[2:2]*/ IfcTextureVertex::Coordinates() const { return *entity->getArgument(0); } -void IfcTextureVertex::setCoordinates(std::vector< double > /*[2:2]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcTextureVertex::is(Type::Enum v) const { return v == Type::IfcTextureVertex; } -Type::Enum IfcTextureVertex::type() const { return Type::IfcTextureVertex; } +std::vector< double > /*[2:2]*/ IfcTextureVertex::Coordinates() const { return *data_->getArgument(0); } +void IfcTextureVertex::setCoordinates(std::vector< double > /*[2:2]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcTextureVertex::declaration() const { return *IfcTextureVertex_type; } Type::Enum IfcTextureVertex::Class() { return Type::IfcTextureVertex; } -IfcTextureVertex::IfcTextureVertex(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTextureVertex)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextureVertex::IfcTextureVertex(std::vector< double > /*[2:2]*/ v1_Coordinates) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); entity = e; EntityBuffer::Add(this); } +IfcTextureVertex::IfcTextureVertex(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTextureVertex)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextureVertex::IfcTextureVertex(std::vector< double > /*[2:2]*/ v1_Coordinates) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcThermalMaterialProperties -bool IfcThermalMaterialProperties::hasSpecificHeatCapacity() const { return !entity->getArgument(1)->isNull(); } -double IfcThermalMaterialProperties::SpecificHeatCapacity() const { return *entity->getArgument(1); } -void IfcThermalMaterialProperties::setSpecificHeatCapacity(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcThermalMaterialProperties::hasBoilingPoint() const { return !entity->getArgument(2)->isNull(); } -double IfcThermalMaterialProperties::BoilingPoint() const { return *entity->getArgument(2); } -void IfcThermalMaterialProperties::setBoilingPoint(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcThermalMaterialProperties::hasFreezingPoint() const { return !entity->getArgument(3)->isNull(); } -double IfcThermalMaterialProperties::FreezingPoint() const { return *entity->getArgument(3); } -void IfcThermalMaterialProperties::setFreezingPoint(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcThermalMaterialProperties::hasThermalConductivity() const { return !entity->getArgument(4)->isNull(); } -double IfcThermalMaterialProperties::ThermalConductivity() const { return *entity->getArgument(4); } -void IfcThermalMaterialProperties::setThermalConductivity(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcThermalMaterialProperties::is(Type::Enum v) const { return v == Type::IfcThermalMaterialProperties || IfcMaterialProperties::is(v); } -Type::Enum IfcThermalMaterialProperties::type() const { return Type::IfcThermalMaterialProperties; } +bool IfcThermalMaterialProperties::hasSpecificHeatCapacity() const { return !data_->getArgument(1)->isNull(); } +double IfcThermalMaterialProperties::SpecificHeatCapacity() const { return *data_->getArgument(1); } +void IfcThermalMaterialProperties::setSpecificHeatCapacity(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcThermalMaterialProperties::hasBoilingPoint() const { return !data_->getArgument(2)->isNull(); } +double IfcThermalMaterialProperties::BoilingPoint() const { return *data_->getArgument(2); } +void IfcThermalMaterialProperties::setBoilingPoint(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcThermalMaterialProperties::hasFreezingPoint() const { return !data_->getArgument(3)->isNull(); } +double IfcThermalMaterialProperties::FreezingPoint() const { return *data_->getArgument(3); } +void IfcThermalMaterialProperties::setFreezingPoint(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcThermalMaterialProperties::hasThermalConductivity() const { return !data_->getArgument(4)->isNull(); } +double IfcThermalMaterialProperties::ThermalConductivity() const { return *data_->getArgument(4); } +void IfcThermalMaterialProperties::setThermalConductivity(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcThermalMaterialProperties::declaration() const { return *IfcThermalMaterialProperties_type; } Type::Enum IfcThermalMaterialProperties::Class() { return Type::IfcThermalMaterialProperties; } -IfcThermalMaterialProperties::IfcThermalMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcThermalMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcThermalMaterialProperties::IfcThermalMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_SpecificHeatCapacity, boost::optional< double > v3_BoilingPoint, boost::optional< double > v4_FreezingPoint, boost::optional< double > v5_ThermalConductivity) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_SpecificHeatCapacity) { e->setArgument(1,(*v2_SpecificHeatCapacity)); } else { e->setArgument(1); } if (v3_BoilingPoint) { e->setArgument(2,(*v3_BoilingPoint)); } else { e->setArgument(2); } if (v4_FreezingPoint) { e->setArgument(3,(*v4_FreezingPoint)); } else { e->setArgument(3); } if (v5_ThermalConductivity) { e->setArgument(4,(*v5_ThermalConductivity)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcThermalMaterialProperties::IfcThermalMaterialProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcThermalMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcThermalMaterialProperties::IfcThermalMaterialProperties(IfcMaterial* v1_Material, boost::optional< double > v2_SpecificHeatCapacity, boost::optional< double > v3_BoilingPoint, boost::optional< double > v4_FreezingPoint, boost::optional< double > v5_ThermalConductivity) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_SpecificHeatCapacity) { e->setArgument(1,(*v2_SpecificHeatCapacity)); } else { e->setArgument(1); } if (v3_BoilingPoint) { e->setArgument(2,(*v3_BoilingPoint)); } else { e->setArgument(2); } if (v4_FreezingPoint) { e->setArgument(3,(*v4_FreezingPoint)); } else { e->setArgument(3); } if (v5_ThermalConductivity) { e->setArgument(4,(*v5_ThermalConductivity)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTimeSeries -std::string IfcTimeSeries::Name() const { return *entity->getArgument(0); } -void IfcTimeSeries::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcTimeSeries::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcTimeSeries::Description() const { return *entity->getArgument(1); } -void IfcTimeSeries::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcDateTimeSelect* IfcTimeSeries::StartTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcTimeSeries::setStartTime(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcDateTimeSelect* IfcTimeSeries::EndTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcTimeSeries::setEndTime(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum IfcTimeSeries::TimeSeriesDataType() const { return IfcTimeSeriesDataTypeEnum::FromString(*entity->getArgument(4)); } -void IfcTimeSeries::setTimeSeriesDataType(IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcTimeSeriesDataTypeEnum::ToString(v)); } -IfcDataOriginEnum::IfcDataOriginEnum IfcTimeSeries::DataOrigin() const { return IfcDataOriginEnum::FromString(*entity->getArgument(5)); } -void IfcTimeSeries::setDataOrigin(IfcDataOriginEnum::IfcDataOriginEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcDataOriginEnum::ToString(v)); } -bool IfcTimeSeries::hasUserDefinedDataOrigin() const { return !entity->getArgument(6)->isNull(); } -std::string IfcTimeSeries::UserDefinedDataOrigin() const { return *entity->getArgument(6); } -void IfcTimeSeries::setUserDefinedDataOrigin(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcTimeSeries::hasUnit() const { return !entity->getArgument(7)->isNull(); } -IfcUnit* IfcTimeSeries::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcTimeSeries::setUnit(IfcUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcTimeSeriesReferenceRelationship::list::ptr IfcTimeSeries::DocumentedBy() const { return entity->getInverse(Type::IfcTimeSeriesReferenceRelationship, 0)->as(); } -bool IfcTimeSeries::is(Type::Enum v) const { return v == Type::IfcTimeSeries; } -Type::Enum IfcTimeSeries::type() const { return Type::IfcTimeSeries; } +std::string IfcTimeSeries::Name() const { return *data_->getArgument(0); } +void IfcTimeSeries::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcTimeSeries::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcTimeSeries::Description() const { return *data_->getArgument(1); } +void IfcTimeSeries::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcDateTimeSelect* IfcTimeSeries::StartTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcTimeSeries::setStartTime(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcDateTimeSelect* IfcTimeSeries::EndTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcTimeSeries::setEndTime(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum IfcTimeSeries::TimeSeriesDataType() const { return IfcTimeSeriesDataTypeEnum::FromString(*data_->getArgument(4)); } +void IfcTimeSeries::setTimeSeriesDataType(IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcTimeSeriesDataTypeEnum::ToString(v)); } +IfcDataOriginEnum::IfcDataOriginEnum IfcTimeSeries::DataOrigin() const { return IfcDataOriginEnum::FromString(*data_->getArgument(5)); } +void IfcTimeSeries::setDataOrigin(IfcDataOriginEnum::IfcDataOriginEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcDataOriginEnum::ToString(v)); } +bool IfcTimeSeries::hasUserDefinedDataOrigin() const { return !data_->getArgument(6)->isNull(); } +std::string IfcTimeSeries::UserDefinedDataOrigin() const { return *data_->getArgument(6); } +void IfcTimeSeries::setUserDefinedDataOrigin(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcTimeSeries::hasUnit() const { return !data_->getArgument(7)->isNull(); } +IfcUnit* IfcTimeSeries::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcTimeSeries::setUnit(IfcUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + +IfcTimeSeriesReferenceRelationship::list::ptr IfcTimeSeries::DocumentedBy() const { return data_->getInverse(Type::IfcTimeSeriesReferenceRelationship, 0)->as(); } + +const IfcParse::entity& IfcTimeSeries::declaration() const { return *IfcTimeSeries_type; } Type::Enum IfcTimeSeries::Class() { return Type::IfcTimeSeries; } -IfcTimeSeries::IfcTimeSeries(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTimeSeries)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTimeSeries::IfcTimeSeries(std::string v1_Name, boost::optional< std::string > v2_Description, IfcDateTimeSelect* v3_StartTime, IfcDateTimeSelect* v4_EndTime, IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v5_TimeSeriesDataType, IfcDataOriginEnum::IfcDataOriginEnum v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, IfcUnit* v8_Unit) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_StartTime)); e->setArgument(3,(v4_EndTime)); e->setArgument(4,v5_TimeSeriesDataType,IfcTimeSeriesDataTypeEnum::ToString(v5_TimeSeriesDataType)); e->setArgument(5,v6_DataOrigin,IfcDataOriginEnum::ToString(v6_DataOrigin)); if (v7_UserDefinedDataOrigin) { e->setArgument(6,(*v7_UserDefinedDataOrigin)); } else { e->setArgument(6); } e->setArgument(7,(v8_Unit)); entity = e; EntityBuffer::Add(this); } +IfcTimeSeries::IfcTimeSeries(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTimeSeries)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTimeSeries::IfcTimeSeries(std::string v1_Name, boost::optional< std::string > v2_Description, IfcDateTimeSelect* v3_StartTime, IfcDateTimeSelect* v4_EndTime, IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v5_TimeSeriesDataType, IfcDataOriginEnum::IfcDataOriginEnum v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, IfcUnit* v8_Unit) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); if (v2_Description) { e->setArgument(1,(*v2_Description)); } else { e->setArgument(1); } e->setArgument(2,(v3_StartTime)); e->setArgument(3,(v4_EndTime)); e->setArgument(4,v5_TimeSeriesDataType,IfcTimeSeriesDataTypeEnum::ToString(v5_TimeSeriesDataType)); e->setArgument(5,v6_DataOrigin,IfcDataOriginEnum::ToString(v6_DataOrigin)); if (v7_UserDefinedDataOrigin) { e->setArgument(6,(*v7_UserDefinedDataOrigin)); } else { e->setArgument(6); } e->setArgument(7,(v8_Unit)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTimeSeriesReferenceRelationship -IfcTimeSeries* IfcTimeSeriesReferenceRelationship::ReferencedTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcTimeSeriesReferenceRelationship::setReferencedTimeSeries(IfcTimeSeries* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcEntityList::ptr IfcTimeSeriesReferenceRelationship::TimeSeriesReferences() const { return *entity->getArgument(1); } -void IfcTimeSeriesReferenceRelationship::setTimeSeriesReferences(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTimeSeriesReferenceRelationship::is(Type::Enum v) const { return v == Type::IfcTimeSeriesReferenceRelationship; } -Type::Enum IfcTimeSeriesReferenceRelationship::type() const { return Type::IfcTimeSeriesReferenceRelationship; } +IfcTimeSeries* IfcTimeSeriesReferenceRelationship::ReferencedTimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcTimeSeriesReferenceRelationship::setReferencedTimeSeries(IfcTimeSeries* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcEntityList::ptr IfcTimeSeriesReferenceRelationship::TimeSeriesReferences() const { return *data_->getArgument(1); } +void IfcTimeSeriesReferenceRelationship::setTimeSeriesReferences(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcTimeSeriesReferenceRelationship::declaration() const { return *IfcTimeSeriesReferenceRelationship_type; } Type::Enum IfcTimeSeriesReferenceRelationship::Class() { return Type::IfcTimeSeriesReferenceRelationship; } -IfcTimeSeriesReferenceRelationship::IfcTimeSeriesReferenceRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTimeSeriesReferenceRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTimeSeriesReferenceRelationship::IfcTimeSeriesReferenceRelationship(IfcTimeSeries* v1_ReferencedTimeSeries, IfcEntityList::ptr v2_TimeSeriesReferences) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ReferencedTimeSeries)); e->setArgument(1,(v2_TimeSeriesReferences)); entity = e; EntityBuffer::Add(this); } +IfcTimeSeriesReferenceRelationship::IfcTimeSeriesReferenceRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTimeSeriesReferenceRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTimeSeriesReferenceRelationship::IfcTimeSeriesReferenceRelationship(IfcTimeSeries* v1_ReferencedTimeSeries, IfcEntityList::ptr v2_TimeSeriesReferences) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ReferencedTimeSeries)); e->setArgument(1,(v2_TimeSeriesReferences)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTimeSeriesSchedule -bool IfcTimeSeriesSchedule::hasApplicableDates() const { return !entity->getArgument(5)->isNull(); } -IfcEntityList::ptr IfcTimeSeriesSchedule::ApplicableDates() const { return *entity->getArgument(5); } -void IfcTimeSeriesSchedule::setApplicableDates(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum IfcTimeSeriesSchedule::TimeSeriesScheduleType() const { return IfcTimeSeriesScheduleTypeEnum::FromString(*entity->getArgument(6)); } -void IfcTimeSeriesSchedule::setTimeSeriesScheduleType(IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcTimeSeriesScheduleTypeEnum::ToString(v)); } -IfcTimeSeries* IfcTimeSeriesSchedule::TimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcTimeSeriesSchedule::setTimeSeries(IfcTimeSeries* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcTimeSeriesSchedule::is(Type::Enum v) const { return v == Type::IfcTimeSeriesSchedule || IfcControl::is(v); } -Type::Enum IfcTimeSeriesSchedule::type() const { return Type::IfcTimeSeriesSchedule; } +bool IfcTimeSeriesSchedule::hasApplicableDates() const { return !data_->getArgument(5)->isNull(); } +IfcEntityList::ptr IfcTimeSeriesSchedule::ApplicableDates() const { return *data_->getArgument(5); } +void IfcTimeSeriesSchedule::setApplicableDates(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum IfcTimeSeriesSchedule::TimeSeriesScheduleType() const { return IfcTimeSeriesScheduleTypeEnum::FromString(*data_->getArgument(6)); } +void IfcTimeSeriesSchedule::setTimeSeriesScheduleType(IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcTimeSeriesScheduleTypeEnum::ToString(v)); } +IfcTimeSeries* IfcTimeSeriesSchedule::TimeSeries() const { return (IfcTimeSeries*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcTimeSeriesSchedule::setTimeSeries(IfcTimeSeries* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcTimeSeriesSchedule::declaration() const { return *IfcTimeSeriesSchedule_type; } Type::Enum IfcTimeSeriesSchedule::Class() { return Type::IfcTimeSeriesSchedule; } -IfcTimeSeriesSchedule::IfcTimeSeriesSchedule(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTimeSeriesSchedule)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTimeSeriesSchedule::IfcTimeSeriesSchedule(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< IfcEntityList::ptr > v6_ApplicableDates, IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum v7_TimeSeriesScheduleType, IfcTimeSeries* v8_TimeSeries) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ApplicableDates) { e->setArgument(5,(*v6_ApplicableDates)); } else { e->setArgument(5); } e->setArgument(6,v7_TimeSeriesScheduleType,IfcTimeSeriesScheduleTypeEnum::ToString(v7_TimeSeriesScheduleType)); e->setArgument(7,(v8_TimeSeries)); entity = e; EntityBuffer::Add(this); } +IfcTimeSeriesSchedule::IfcTimeSeriesSchedule(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTimeSeriesSchedule)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTimeSeriesSchedule::IfcTimeSeriesSchedule(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< IfcEntityList::ptr > v6_ApplicableDates, IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum v7_TimeSeriesScheduleType, IfcTimeSeries* v8_TimeSeries) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } if (v6_ApplicableDates) { e->setArgument(5,(*v6_ApplicableDates)); } else { e->setArgument(5); } e->setArgument(6,v7_TimeSeriesScheduleType,IfcTimeSeriesScheduleTypeEnum::ToString(v7_TimeSeriesScheduleType)); e->setArgument(7,(v8_TimeSeries)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTimeSeriesValue -IfcEntityList::ptr IfcTimeSeriesValue::ListValues() const { return *entity->getArgument(0); } -void IfcTimeSeriesValue::setListValues(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcTimeSeriesValue::is(Type::Enum v) const { return v == Type::IfcTimeSeriesValue; } -Type::Enum IfcTimeSeriesValue::type() const { return Type::IfcTimeSeriesValue; } +IfcEntityList::ptr IfcTimeSeriesValue::ListValues() const { return *data_->getArgument(0); } +void IfcTimeSeriesValue::setListValues(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcTimeSeriesValue::declaration() const { return *IfcTimeSeriesValue_type; } Type::Enum IfcTimeSeriesValue::Class() { return Type::IfcTimeSeriesValue; } -IfcTimeSeriesValue::IfcTimeSeriesValue(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTimeSeriesValue)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTimeSeriesValue::IfcTimeSeriesValue(IfcEntityList::ptr v1_ListValues) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ListValues)); entity = e; EntityBuffer::Add(this); } +IfcTimeSeriesValue::IfcTimeSeriesValue(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTimeSeriesValue)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTimeSeriesValue::IfcTimeSeriesValue(IfcEntityList::ptr v1_ListValues) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ListValues)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTopologicalRepresentationItem -bool IfcTopologicalRepresentationItem::is(Type::Enum v) const { return v == Type::IfcTopologicalRepresentationItem || IfcRepresentationItem::is(v); } -Type::Enum IfcTopologicalRepresentationItem::type() const { return Type::IfcTopologicalRepresentationItem; } + + +const IfcParse::entity& IfcTopologicalRepresentationItem::declaration() const { return *IfcTopologicalRepresentationItem_type; } Type::Enum IfcTopologicalRepresentationItem::Class() { return Type::IfcTopologicalRepresentationItem; } -IfcTopologicalRepresentationItem::IfcTopologicalRepresentationItem(IfcAbstractEntity* e) : IfcRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTopologicalRepresentationItem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTopologicalRepresentationItem::IfcTopologicalRepresentationItem() : IfcRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcTopologicalRepresentationItem::IfcTopologicalRepresentationItem(IfcAbstractEntity* e) : IfcRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTopologicalRepresentationItem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTopologicalRepresentationItem::IfcTopologicalRepresentationItem() : IfcRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTopologyRepresentation -bool IfcTopologyRepresentation::is(Type::Enum v) const { return v == Type::IfcTopologyRepresentation || IfcShapeModel::is(v); } -Type::Enum IfcTopologyRepresentation::type() const { return Type::IfcTopologyRepresentation; } + + +const IfcParse::entity& IfcTopologyRepresentation::declaration() const { return *IfcTopologyRepresentation_type; } Type::Enum IfcTopologyRepresentation::Class() { return Type::IfcTopologyRepresentation; } -IfcTopologyRepresentation::IfcTopologyRepresentation(IfcAbstractEntity* e) : IfcShapeModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTopologyRepresentation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTopologyRepresentation::IfcTopologyRepresentation(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcShapeModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcTopologyRepresentation::IfcTopologyRepresentation(IfcAbstractEntity* e) : IfcShapeModel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTopologyRepresentation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTopologyRepresentation::IfcTopologyRepresentation(IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items) : IfcShapeModel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ContextOfItems)); if (v2_RepresentationIdentifier) { e->setArgument(1,(*v2_RepresentationIdentifier)); } else { e->setArgument(1); } if (v3_RepresentationType) { e->setArgument(2,(*v3_RepresentationType)); } else { e->setArgument(2); } e->setArgument(3,(v4_Items)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTransformerType -IfcTransformerTypeEnum::IfcTransformerTypeEnum IfcTransformerType::PredefinedType() const { return IfcTransformerTypeEnum::FromString(*entity->getArgument(9)); } -void IfcTransformerType::setPredefinedType(IfcTransformerTypeEnum::IfcTransformerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcTransformerTypeEnum::ToString(v)); } -bool IfcTransformerType::is(Type::Enum v) const { return v == Type::IfcTransformerType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcTransformerType::type() const { return Type::IfcTransformerType; } +IfcTransformerTypeEnum::IfcTransformerTypeEnum IfcTransformerType::PredefinedType() const { return IfcTransformerTypeEnum::FromString(*data_->getArgument(9)); } +void IfcTransformerType::setPredefinedType(IfcTransformerTypeEnum::IfcTransformerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcTransformerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcTransformerType::declaration() const { return *IfcTransformerType_type; } Type::Enum IfcTransformerType::Class() { return Type::IfcTransformerType; } -IfcTransformerType::IfcTransformerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTransformerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTransformerType::IfcTransformerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTransformerTypeEnum::IfcTransformerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTransformerTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcTransformerType::IfcTransformerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTransformerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTransformerType::IfcTransformerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTransformerTypeEnum::IfcTransformerTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTransformerTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTransportElement -bool IfcTransportElement::hasOperationType() const { return !entity->getArgument(8)->isNull(); } -IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElement::OperationType() const { return IfcTransportElementTypeEnum::FromString(*entity->getArgument(8)); } -void IfcTransportElement::setOperationType(IfcTransportElementTypeEnum::IfcTransportElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcTransportElementTypeEnum::ToString(v)); } -bool IfcTransportElement::hasCapacityByWeight() const { return !entity->getArgument(9)->isNull(); } -double IfcTransportElement::CapacityByWeight() const { return *entity->getArgument(9); } -void IfcTransportElement::setCapacityByWeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcTransportElement::hasCapacityByNumber() const { return !entity->getArgument(10)->isNull(); } -double IfcTransportElement::CapacityByNumber() const { return *entity->getArgument(10); } -void IfcTransportElement::setCapacityByNumber(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcTransportElement::is(Type::Enum v) const { return v == Type::IfcTransportElement || IfcElement::is(v); } -Type::Enum IfcTransportElement::type() const { return Type::IfcTransportElement; } +bool IfcTransportElement::hasOperationType() const { return !data_->getArgument(8)->isNull(); } +IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElement::OperationType() const { return IfcTransportElementTypeEnum::FromString(*data_->getArgument(8)); } +void IfcTransportElement::setOperationType(IfcTransportElementTypeEnum::IfcTransportElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcTransportElementTypeEnum::ToString(v)); } +bool IfcTransportElement::hasCapacityByWeight() const { return !data_->getArgument(9)->isNull(); } +double IfcTransportElement::CapacityByWeight() const { return *data_->getArgument(9); } +void IfcTransportElement::setCapacityByWeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcTransportElement::hasCapacityByNumber() const { return !data_->getArgument(10)->isNull(); } +double IfcTransportElement::CapacityByNumber() const { return *data_->getArgument(10); } +void IfcTransportElement::setCapacityByNumber(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcTransportElement::declaration() const { return *IfcTransportElement_type; } Type::Enum IfcTransportElement::Class() { return Type::IfcTransportElement; } -IfcTransportElement::IfcTransportElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTransportElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTransportElement::IfcTransportElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcTransportElementTypeEnum::IfcTransportElementTypeEnum > v9_OperationType, boost::optional< double > v10_CapacityByWeight, boost::optional< double > v11_CapacityByNumber) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_OperationType) { e->setArgument(8,*v9_OperationType,IfcTransportElementTypeEnum::ToString(*v9_OperationType)); } else { e->setArgument(8); } if (v10_CapacityByWeight) { e->setArgument(9,(*v10_CapacityByWeight)); } else { e->setArgument(9); } if (v11_CapacityByNumber) { e->setArgument(10,(*v11_CapacityByNumber)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcTransportElement::IfcTransportElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTransportElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTransportElement::IfcTransportElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcTransportElementTypeEnum::IfcTransportElementTypeEnum > v9_OperationType, boost::optional< double > v10_CapacityByWeight, boost::optional< double > v11_CapacityByNumber) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_OperationType) { e->setArgument(8,*v9_OperationType,IfcTransportElementTypeEnum::ToString(*v9_OperationType)); } else { e->setArgument(8); } if (v10_CapacityByWeight) { e->setArgument(9,(*v10_CapacityByWeight)); } else { e->setArgument(9); } if (v11_CapacityByNumber) { e->setArgument(10,(*v11_CapacityByNumber)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTransportElementType -IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElementType::PredefinedType() const { return IfcTransportElementTypeEnum::FromString(*entity->getArgument(9)); } -void IfcTransportElementType::setPredefinedType(IfcTransportElementTypeEnum::IfcTransportElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcTransportElementTypeEnum::ToString(v)); } -bool IfcTransportElementType::is(Type::Enum v) const { return v == Type::IfcTransportElementType || IfcElementType::is(v); } -Type::Enum IfcTransportElementType::type() const { return Type::IfcTransportElementType; } +IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElementType::PredefinedType() const { return IfcTransportElementTypeEnum::FromString(*data_->getArgument(9)); } +void IfcTransportElementType::setPredefinedType(IfcTransportElementTypeEnum::IfcTransportElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcTransportElementTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcTransportElementType::declaration() const { return *IfcTransportElementType_type; } Type::Enum IfcTransportElementType::Class() { return Type::IfcTransportElementType; } -IfcTransportElementType::IfcTransportElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTransportElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTransportElementType::IfcTransportElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTransportElementTypeEnum::IfcTransportElementTypeEnum v10_PredefinedType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTransportElementTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcTransportElementType::IfcTransportElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTransportElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTransportElementType::IfcTransportElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTransportElementTypeEnum::IfcTransportElementTypeEnum v10_PredefinedType) : IfcElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTransportElementTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTrapeziumProfileDef -double IfcTrapeziumProfileDef::BottomXDim() const { return *entity->getArgument(3); } -void IfcTrapeziumProfileDef::setBottomXDim(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcTrapeziumProfileDef::TopXDim() const { return *entity->getArgument(4); } -void IfcTrapeziumProfileDef::setTopXDim(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -double IfcTrapeziumProfileDef::YDim() const { return *entity->getArgument(5); } -void IfcTrapeziumProfileDef::setYDim(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcTrapeziumProfileDef::TopXOffset() const { return *entity->getArgument(6); } -void IfcTrapeziumProfileDef::setTopXOffset(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcTrapeziumProfileDef::is(Type::Enum v) const { return v == Type::IfcTrapeziumProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcTrapeziumProfileDef::type() const { return Type::IfcTrapeziumProfileDef; } +double IfcTrapeziumProfileDef::BottomXDim() const { return *data_->getArgument(3); } +void IfcTrapeziumProfileDef::setBottomXDim(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcTrapeziumProfileDef::TopXDim() const { return *data_->getArgument(4); } +void IfcTrapeziumProfileDef::setTopXDim(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +double IfcTrapeziumProfileDef::YDim() const { return *data_->getArgument(5); } +void IfcTrapeziumProfileDef::setYDim(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcTrapeziumProfileDef::TopXOffset() const { return *data_->getArgument(6); } +void IfcTrapeziumProfileDef::setTopXOffset(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcTrapeziumProfileDef::declaration() const { return *IfcTrapeziumProfileDef_type; } Type::Enum IfcTrapeziumProfileDef::Class() { return Type::IfcTrapeziumProfileDef; } -IfcTrapeziumProfileDef::IfcTrapeziumProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTrapeziumProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTrapeziumProfileDef::IfcTrapeziumProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_BottomXDim, double v5_TopXDim, double v6_YDim, double v7_TopXOffset) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_BottomXDim)); e->setArgument(4,(v5_TopXDim)); e->setArgument(5,(v6_YDim)); e->setArgument(6,(v7_TopXOffset)); entity = e; EntityBuffer::Add(this); } +IfcTrapeziumProfileDef::IfcTrapeziumProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTrapeziumProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTrapeziumProfileDef::IfcTrapeziumProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_BottomXDim, double v5_TopXDim, double v6_YDim, double v7_TopXOffset) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_BottomXDim)); e->setArgument(4,(v5_TopXDim)); e->setArgument(5,(v6_YDim)); e->setArgument(6,(v7_TopXOffset)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTrimmedCurve -IfcCurve* IfcTrimmedCurve::BasisCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcTrimmedCurve::setBasisCurve(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcEntityList::ptr IfcTrimmedCurve::Trim1() const { return *entity->getArgument(1); } -void IfcTrimmedCurve::setTrim1(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcEntityList::ptr IfcTrimmedCurve::Trim2() const { return *entity->getArgument(2); } -void IfcTrimmedCurve::setTrim2(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcTrimmedCurve::SenseAgreement() const { return *entity->getArgument(3); } -void IfcTrimmedCurve::setSenseAgreement(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -IfcTrimmingPreference::IfcTrimmingPreference IfcTrimmedCurve::MasterRepresentation() const { return IfcTrimmingPreference::FromString(*entity->getArgument(4)); } -void IfcTrimmedCurve::setMasterRepresentation(IfcTrimmingPreference::IfcTrimmingPreference v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcTrimmingPreference::ToString(v)); } -bool IfcTrimmedCurve::is(Type::Enum v) const { return v == Type::IfcTrimmedCurve || IfcBoundedCurve::is(v); } -Type::Enum IfcTrimmedCurve::type() const { return Type::IfcTrimmedCurve; } +IfcCurve* IfcTrimmedCurve::BasisCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcTrimmedCurve::setBasisCurve(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcEntityList::ptr IfcTrimmedCurve::Trim1() const { return *data_->getArgument(1); } +void IfcTrimmedCurve::setTrim1(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcEntityList::ptr IfcTrimmedCurve::Trim2() const { return *data_->getArgument(2); } +void IfcTrimmedCurve::setTrim2(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcTrimmedCurve::SenseAgreement() const { return *data_->getArgument(3); } +void IfcTrimmedCurve::setSenseAgreement(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +IfcTrimmingPreference::IfcTrimmingPreference IfcTrimmedCurve::MasterRepresentation() const { return IfcTrimmingPreference::FromString(*data_->getArgument(4)); } +void IfcTrimmedCurve::setMasterRepresentation(IfcTrimmingPreference::IfcTrimmingPreference v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcTrimmingPreference::ToString(v)); } + + +const IfcParse::entity& IfcTrimmedCurve::declaration() const { return *IfcTrimmedCurve_type; } Type::Enum IfcTrimmedCurve::Class() { return Type::IfcTrimmedCurve; } -IfcTrimmedCurve::IfcTrimmedCurve(IfcAbstractEntity* e) : IfcBoundedCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTrimmedCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTrimmedCurve::IfcTrimmedCurve(IfcCurve* v1_BasisCurve, IfcEntityList::ptr v2_Trim1, IfcEntityList::ptr v3_Trim2, bool v4_SenseAgreement, IfcTrimmingPreference::IfcTrimmingPreference v5_MasterRepresentation) : IfcBoundedCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisCurve)); e->setArgument(1,(v2_Trim1)); e->setArgument(2,(v3_Trim2)); e->setArgument(3,(v4_SenseAgreement)); e->setArgument(4,v5_MasterRepresentation,IfcTrimmingPreference::ToString(v5_MasterRepresentation)); entity = e; EntityBuffer::Add(this); } +IfcTrimmedCurve::IfcTrimmedCurve(IfcAbstractEntity* e) : IfcBoundedCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTrimmedCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTrimmedCurve::IfcTrimmedCurve(IfcCurve* v1_BasisCurve, IfcEntityList::ptr v2_Trim1, IfcEntityList::ptr v3_Trim2, bool v4_SenseAgreement, IfcTrimmingPreference::IfcTrimmingPreference v5_MasterRepresentation) : IfcBoundedCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisCurve)); e->setArgument(1,(v2_Trim1)); e->setArgument(2,(v3_Trim2)); e->setArgument(3,(v4_SenseAgreement)); e->setArgument(4,v5_MasterRepresentation,IfcTrimmingPreference::ToString(v5_MasterRepresentation)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTubeBundleType -IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum IfcTubeBundleType::PredefinedType() const { return IfcTubeBundleTypeEnum::FromString(*entity->getArgument(9)); } -void IfcTubeBundleType::setPredefinedType(IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcTubeBundleTypeEnum::ToString(v)); } -bool IfcTubeBundleType::is(Type::Enum v) const { return v == Type::IfcTubeBundleType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcTubeBundleType::type() const { return Type::IfcTubeBundleType; } +IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum IfcTubeBundleType::PredefinedType() const { return IfcTubeBundleTypeEnum::FromString(*data_->getArgument(9)); } +void IfcTubeBundleType::setPredefinedType(IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcTubeBundleTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcTubeBundleType::declaration() const { return *IfcTubeBundleType_type; } Type::Enum IfcTubeBundleType::Class() { return Type::IfcTubeBundleType; } -IfcTubeBundleType::IfcTubeBundleType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTubeBundleType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTubeBundleType::IfcTubeBundleType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTubeBundleTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcTubeBundleType::IfcTubeBundleType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTubeBundleType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTubeBundleType::IfcTubeBundleType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTubeBundleTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTwoDirectionRepeatFactor -IfcVector* IfcTwoDirectionRepeatFactor::SecondRepeatFactor() const { return (IfcVector*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcTwoDirectionRepeatFactor::setSecondRepeatFactor(IfcVector* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTwoDirectionRepeatFactor::is(Type::Enum v) const { return v == Type::IfcTwoDirectionRepeatFactor || IfcOneDirectionRepeatFactor::is(v); } -Type::Enum IfcTwoDirectionRepeatFactor::type() const { return Type::IfcTwoDirectionRepeatFactor; } +IfcVector* IfcTwoDirectionRepeatFactor::SecondRepeatFactor() const { return (IfcVector*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcTwoDirectionRepeatFactor::setSecondRepeatFactor(IfcVector* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcTwoDirectionRepeatFactor::declaration() const { return *IfcTwoDirectionRepeatFactor_type; } Type::Enum IfcTwoDirectionRepeatFactor::Class() { return Type::IfcTwoDirectionRepeatFactor; } -IfcTwoDirectionRepeatFactor::IfcTwoDirectionRepeatFactor(IfcAbstractEntity* e) : IfcOneDirectionRepeatFactor((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTwoDirectionRepeatFactor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTwoDirectionRepeatFactor::IfcTwoDirectionRepeatFactor(IfcVector* v1_RepeatFactor, IfcVector* v2_SecondRepeatFactor) : IfcOneDirectionRepeatFactor((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatFactor)); e->setArgument(1,(v2_SecondRepeatFactor)); entity = e; EntityBuffer::Add(this); } +IfcTwoDirectionRepeatFactor::IfcTwoDirectionRepeatFactor(IfcAbstractEntity* e) : IfcOneDirectionRepeatFactor((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTwoDirectionRepeatFactor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTwoDirectionRepeatFactor::IfcTwoDirectionRepeatFactor(IfcVector* v1_RepeatFactor, IfcVector* v2_SecondRepeatFactor) : IfcOneDirectionRepeatFactor((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatFactor)); e->setArgument(1,(v2_SecondRepeatFactor)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTypeObject -bool IfcTypeObject::hasApplicableOccurrence() const { return !entity->getArgument(4)->isNull(); } -std::string IfcTypeObject::ApplicableOccurrence() const { return *entity->getArgument(4); } -void IfcTypeObject::setApplicableOccurrence(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcTypeObject::hasHasPropertySets() const { return !entity->getArgument(5)->isNull(); } -IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr IfcTypeObject::HasPropertySets() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcTypeObject::setHasPropertySets(IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v->generalize()); } -IfcRelDefinesByType::list::ptr IfcTypeObject::ObjectTypeOf() const { return entity->getInverse(Type::IfcRelDefinesByType, 5)->as(); } -bool IfcTypeObject::is(Type::Enum v) const { return v == Type::IfcTypeObject || IfcObjectDefinition::is(v); } -Type::Enum IfcTypeObject::type() const { return Type::IfcTypeObject; } +bool IfcTypeObject::hasApplicableOccurrence() const { return !data_->getArgument(4)->isNull(); } +std::string IfcTypeObject::ApplicableOccurrence() const { return *data_->getArgument(4); } +void IfcTypeObject::setApplicableOccurrence(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcTypeObject::hasHasPropertySets() const { return !data_->getArgument(5)->isNull(); } +IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr IfcTypeObject::HasPropertySets() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcTypeObject::setHasPropertySets(IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v->generalize()); } + +IfcRelDefinesByType::list::ptr IfcTypeObject::ObjectTypeOf() const { return data_->getInverse(Type::IfcRelDefinesByType, 5)->as(); } + +const IfcParse::entity& IfcTypeObject::declaration() const { return *IfcTypeObject_type; } Type::Enum IfcTypeObject::Class() { return Type::IfcTypeObject; } -IfcTypeObject::IfcTypeObject(IfcAbstractEntity* e) : IfcObjectDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTypeObject)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTypeObject::IfcTypeObject(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets) : IfcObjectDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcTypeObject::IfcTypeObject(IfcAbstractEntity* e) : IfcObjectDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTypeObject)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTypeObject::IfcTypeObject(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets) : IfcObjectDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTypeProduct -bool IfcTypeProduct::hasRepresentationMaps() const { return !entity->getArgument(6)->isNull(); } -IfcTemplatedEntityList< IfcRepresentationMap >::ptr IfcTypeProduct::RepresentationMaps() const { IfcEntityList::ptr es = *entity->getArgument(6); return es->as(); } -void IfcTypeProduct::setRepresentationMaps(IfcTemplatedEntityList< IfcRepresentationMap >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v->generalize()); } -bool IfcTypeProduct::hasTag() const { return !entity->getArgument(7)->isNull(); } -std::string IfcTypeProduct::Tag() const { return *entity->getArgument(7); } -void IfcTypeProduct::setTag(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcTypeProduct::is(Type::Enum v) const { return v == Type::IfcTypeProduct || IfcTypeObject::is(v); } -Type::Enum IfcTypeProduct::type() const { return Type::IfcTypeProduct; } +bool IfcTypeProduct::hasRepresentationMaps() const { return !data_->getArgument(6)->isNull(); } +IfcTemplatedEntityList< IfcRepresentationMap >::ptr IfcTypeProduct::RepresentationMaps() const { IfcEntityList::ptr es = *data_->getArgument(6); return es->as(); } +void IfcTypeProduct::setRepresentationMaps(IfcTemplatedEntityList< IfcRepresentationMap >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v->generalize()); } +bool IfcTypeProduct::hasTag() const { return !data_->getArgument(7)->isNull(); } +std::string IfcTypeProduct::Tag() const { return *data_->getArgument(7); } +void IfcTypeProduct::setTag(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcTypeProduct::declaration() const { return *IfcTypeProduct_type; } Type::Enum IfcTypeProduct::Class() { return Type::IfcTypeProduct; } -IfcTypeProduct::IfcTypeProduct(IfcAbstractEntity* e) : IfcTypeObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTypeProduct)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTypeProduct::IfcTypeProduct(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag) : IfcTypeObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcTypeProduct::IfcTypeProduct(IfcAbstractEntity* e) : IfcTypeObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTypeProduct)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTypeProduct::IfcTypeProduct(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag) : IfcTypeObject((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcUShapeProfileDef -double IfcUShapeProfileDef::Depth() const { return *entity->getArgument(3); } -void IfcUShapeProfileDef::setDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcUShapeProfileDef::FlangeWidth() const { return *entity->getArgument(4); } -void IfcUShapeProfileDef::setFlangeWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -double IfcUShapeProfileDef::WebThickness() const { return *entity->getArgument(5); } -void IfcUShapeProfileDef::setWebThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcUShapeProfileDef::FlangeThickness() const { return *entity->getArgument(6); } -void IfcUShapeProfileDef::setFlangeThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcUShapeProfileDef::hasFilletRadius() const { return !entity->getArgument(7)->isNull(); } -double IfcUShapeProfileDef::FilletRadius() const { return *entity->getArgument(7); } -void IfcUShapeProfileDef::setFilletRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcUShapeProfileDef::hasEdgeRadius() const { return !entity->getArgument(8)->isNull(); } -double IfcUShapeProfileDef::EdgeRadius() const { return *entity->getArgument(8); } -void IfcUShapeProfileDef::setEdgeRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcUShapeProfileDef::hasFlangeSlope() const { return !entity->getArgument(9)->isNull(); } -double IfcUShapeProfileDef::FlangeSlope() const { return *entity->getArgument(9); } -void IfcUShapeProfileDef::setFlangeSlope(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcUShapeProfileDef::hasCentreOfGravityInX() const { return !entity->getArgument(10)->isNull(); } -double IfcUShapeProfileDef::CentreOfGravityInX() const { return *entity->getArgument(10); } -void IfcUShapeProfileDef::setCentreOfGravityInX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcUShapeProfileDef::is(Type::Enum v) const { return v == Type::IfcUShapeProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcUShapeProfileDef::type() const { return Type::IfcUShapeProfileDef; } +double IfcUShapeProfileDef::Depth() const { return *data_->getArgument(3); } +void IfcUShapeProfileDef::setDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcUShapeProfileDef::FlangeWidth() const { return *data_->getArgument(4); } +void IfcUShapeProfileDef::setFlangeWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +double IfcUShapeProfileDef::WebThickness() const { return *data_->getArgument(5); } +void IfcUShapeProfileDef::setWebThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcUShapeProfileDef::FlangeThickness() const { return *data_->getArgument(6); } +void IfcUShapeProfileDef::setFlangeThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcUShapeProfileDef::hasFilletRadius() const { return !data_->getArgument(7)->isNull(); } +double IfcUShapeProfileDef::FilletRadius() const { return *data_->getArgument(7); } +void IfcUShapeProfileDef::setFilletRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcUShapeProfileDef::hasEdgeRadius() const { return !data_->getArgument(8)->isNull(); } +double IfcUShapeProfileDef::EdgeRadius() const { return *data_->getArgument(8); } +void IfcUShapeProfileDef::setEdgeRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcUShapeProfileDef::hasFlangeSlope() const { return !data_->getArgument(9)->isNull(); } +double IfcUShapeProfileDef::FlangeSlope() const { return *data_->getArgument(9); } +void IfcUShapeProfileDef::setFlangeSlope(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcUShapeProfileDef::hasCentreOfGravityInX() const { return !data_->getArgument(10)->isNull(); } +double IfcUShapeProfileDef::CentreOfGravityInX() const { return *data_->getArgument(10); } +void IfcUShapeProfileDef::setCentreOfGravityInX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcUShapeProfileDef::declaration() const { return *IfcUShapeProfileDef_type; } Type::Enum IfcUShapeProfileDef::Class() { return Type::IfcUShapeProfileDef; } -IfcUShapeProfileDef::IfcUShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcUShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcUShapeProfileDef::IfcUShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_EdgeRadius, boost::optional< double > v10_FlangeSlope, boost::optional< double > v11_CentreOfGravityInX) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Depth)); e->setArgument(4,(v5_FlangeWidth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_FlangeThickness)); if (v8_FilletRadius) { e->setArgument(7,(*v8_FilletRadius)); } else { e->setArgument(7); } if (v9_EdgeRadius) { e->setArgument(8,(*v9_EdgeRadius)); } else { e->setArgument(8); } if (v10_FlangeSlope) { e->setArgument(9,(*v10_FlangeSlope)); } else { e->setArgument(9); } if (v11_CentreOfGravityInX) { e->setArgument(10,(*v11_CentreOfGravityInX)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcUShapeProfileDef::IfcUShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcUShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcUShapeProfileDef::IfcUShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_EdgeRadius, boost::optional< double > v10_FlangeSlope, boost::optional< double > v11_CentreOfGravityInX) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Depth)); e->setArgument(4,(v5_FlangeWidth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_FlangeThickness)); if (v8_FilletRadius) { e->setArgument(7,(*v8_FilletRadius)); } else { e->setArgument(7); } if (v9_EdgeRadius) { e->setArgument(8,(*v9_EdgeRadius)); } else { e->setArgument(8); } if (v10_FlangeSlope) { e->setArgument(9,(*v10_FlangeSlope)); } else { e->setArgument(9); } if (v11_CentreOfGravityInX) { e->setArgument(10,(*v11_CentreOfGravityInX)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcUnitAssignment -IfcEntityList::ptr IfcUnitAssignment::Units() const { return *entity->getArgument(0); } -void IfcUnitAssignment::setUnits(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcUnitAssignment::is(Type::Enum v) const { return v == Type::IfcUnitAssignment; } -Type::Enum IfcUnitAssignment::type() const { return Type::IfcUnitAssignment; } +IfcEntityList::ptr IfcUnitAssignment::Units() const { return *data_->getArgument(0); } +void IfcUnitAssignment::setUnits(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcUnitAssignment::declaration() const { return *IfcUnitAssignment_type; } Type::Enum IfcUnitAssignment::Class() { return Type::IfcUnitAssignment; } -IfcUnitAssignment::IfcUnitAssignment(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcUnitAssignment)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcUnitAssignment::IfcUnitAssignment(IfcEntityList::ptr v1_Units) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Units)); entity = e; EntityBuffer::Add(this); } +IfcUnitAssignment::IfcUnitAssignment(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcUnitAssignment)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcUnitAssignment::IfcUnitAssignment(IfcEntityList::ptr v1_Units) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Units)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcUnitaryEquipmentType -IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum IfcUnitaryEquipmentType::PredefinedType() const { return IfcUnitaryEquipmentTypeEnum::FromString(*entity->getArgument(9)); } -void IfcUnitaryEquipmentType::setPredefinedType(IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcUnitaryEquipmentTypeEnum::ToString(v)); } -bool IfcUnitaryEquipmentType::is(Type::Enum v) const { return v == Type::IfcUnitaryEquipmentType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcUnitaryEquipmentType::type() const { return Type::IfcUnitaryEquipmentType; } +IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum IfcUnitaryEquipmentType::PredefinedType() const { return IfcUnitaryEquipmentTypeEnum::FromString(*data_->getArgument(9)); } +void IfcUnitaryEquipmentType::setPredefinedType(IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcUnitaryEquipmentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcUnitaryEquipmentType::declaration() const { return *IfcUnitaryEquipmentType_type; } Type::Enum IfcUnitaryEquipmentType::Class() { return Type::IfcUnitaryEquipmentType; } -IfcUnitaryEquipmentType::IfcUnitaryEquipmentType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcUnitaryEquipmentType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcUnitaryEquipmentType::IfcUnitaryEquipmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcUnitaryEquipmentTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcUnitaryEquipmentType::IfcUnitaryEquipmentType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcUnitaryEquipmentType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcUnitaryEquipmentType::IfcUnitaryEquipmentType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum v10_PredefinedType) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcUnitaryEquipmentTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcValveType -IfcValveTypeEnum::IfcValveTypeEnum IfcValveType::PredefinedType() const { return IfcValveTypeEnum::FromString(*entity->getArgument(9)); } -void IfcValveType::setPredefinedType(IfcValveTypeEnum::IfcValveTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcValveTypeEnum::ToString(v)); } -bool IfcValveType::is(Type::Enum v) const { return v == Type::IfcValveType || IfcFlowControllerType::is(v); } -Type::Enum IfcValveType::type() const { return Type::IfcValveType; } +IfcValveTypeEnum::IfcValveTypeEnum IfcValveType::PredefinedType() const { return IfcValveTypeEnum::FromString(*data_->getArgument(9)); } +void IfcValveType::setPredefinedType(IfcValveTypeEnum::IfcValveTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcValveTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcValveType::declaration() const { return *IfcValveType_type; } Type::Enum IfcValveType::Class() { return Type::IfcValveType; } -IfcValveType::IfcValveType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcValveType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcValveType::IfcValveType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcValveTypeEnum::IfcValveTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcValveTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcValveType::IfcValveType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcValveType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcValveType::IfcValveType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcValveTypeEnum::IfcValveTypeEnum v10_PredefinedType) : IfcFlowControllerType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcValveTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcVector -IfcDirection* IfcVector::Orientation() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcVector::setOrientation(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -double IfcVector::Magnitude() const { return *entity->getArgument(1); } -void IfcVector::setMagnitude(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcVector::is(Type::Enum v) const { return v == Type::IfcVector || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcVector::type() const { return Type::IfcVector; } +IfcDirection* IfcVector::Orientation() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcVector::setOrientation(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +double IfcVector::Magnitude() const { return *data_->getArgument(1); } +void IfcVector::setMagnitude(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcVector::declaration() const { return *IfcVector_type; } Type::Enum IfcVector::Class() { return Type::IfcVector; } -IfcVector::IfcVector(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVector)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcVector::IfcVector(IfcDirection* v1_Orientation, double v2_Magnitude) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Orientation)); e->setArgument(1,(v2_Magnitude)); entity = e; EntityBuffer::Add(this); } +IfcVector::IfcVector(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVector)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcVector::IfcVector(IfcDirection* v1_Orientation, double v2_Magnitude) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Orientation)); e->setArgument(1,(v2_Magnitude)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcVertex -bool IfcVertex::is(Type::Enum v) const { return v == Type::IfcVertex || IfcTopologicalRepresentationItem::is(v); } -Type::Enum IfcVertex::type() const { return Type::IfcVertex; } + + +const IfcParse::entity& IfcVertex::declaration() const { return *IfcVertex_type; } Type::Enum IfcVertex::Class() { return Type::IfcVertex; } -IfcVertex::IfcVertex(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVertex)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcVertex::IfcVertex() : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcVertex::IfcVertex(IfcAbstractEntity* e) : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVertex)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcVertex::IfcVertex() : IfcTopologicalRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcVertexBasedTextureMap -IfcTemplatedEntityList< IfcTextureVertex >::ptr IfcVertexBasedTextureMap::TextureVertices() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcVertexBasedTextureMap::setTextureVertices(IfcTemplatedEntityList< IfcTextureVertex >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -IfcTemplatedEntityList< IfcCartesianPoint >::ptr IfcVertexBasedTextureMap::TexturePoints() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcVertexBasedTextureMap::setTexturePoints(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcVertexBasedTextureMap::is(Type::Enum v) const { return v == Type::IfcVertexBasedTextureMap; } -Type::Enum IfcVertexBasedTextureMap::type() const { return Type::IfcVertexBasedTextureMap; } +IfcTemplatedEntityList< IfcTextureVertex >::ptr IfcVertexBasedTextureMap::TextureVertices() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcVertexBasedTextureMap::setTextureVertices(IfcTemplatedEntityList< IfcTextureVertex >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } +IfcTemplatedEntityList< IfcCartesianPoint >::ptr IfcVertexBasedTextureMap::TexturePoints() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcVertexBasedTextureMap::setTexturePoints(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } + + +const IfcParse::entity& IfcVertexBasedTextureMap::declaration() const { return *IfcVertexBasedTextureMap_type; } Type::Enum IfcVertexBasedTextureMap::Class() { return Type::IfcVertexBasedTextureMap; } -IfcVertexBasedTextureMap::IfcVertexBasedTextureMap(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcVertexBasedTextureMap)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcVertexBasedTextureMap::IfcVertexBasedTextureMap(IfcTemplatedEntityList< IfcTextureVertex >::ptr v1_TextureVertices, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_TexturePoints) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TextureVertices)->generalize()); e->setArgument(1,(v2_TexturePoints)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcVertexBasedTextureMap::IfcVertexBasedTextureMap(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcVertexBasedTextureMap)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcVertexBasedTextureMap::IfcVertexBasedTextureMap(IfcTemplatedEntityList< IfcTextureVertex >::ptr v1_TextureVertices, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_TexturePoints) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TextureVertices)->generalize()); e->setArgument(1,(v2_TexturePoints)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcVertexLoop -IfcVertex* IfcVertexLoop::LoopVertex() const { return (IfcVertex*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcVertexLoop::setLoopVertex(IfcVertex* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcVertexLoop::is(Type::Enum v) const { return v == Type::IfcVertexLoop || IfcLoop::is(v); } -Type::Enum IfcVertexLoop::type() const { return Type::IfcVertexLoop; } +IfcVertex* IfcVertexLoop::LoopVertex() const { return (IfcVertex*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcVertexLoop::setLoopVertex(IfcVertex* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcVertexLoop::declaration() const { return *IfcVertexLoop_type; } Type::Enum IfcVertexLoop::Class() { return Type::IfcVertexLoop; } -IfcVertexLoop::IfcVertexLoop(IfcAbstractEntity* e) : IfcLoop((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVertexLoop)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcVertexLoop::IfcVertexLoop(IfcVertex* v1_LoopVertex) : IfcLoop((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_LoopVertex)); entity = e; EntityBuffer::Add(this); } +IfcVertexLoop::IfcVertexLoop(IfcAbstractEntity* e) : IfcLoop((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVertexLoop)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcVertexLoop::IfcVertexLoop(IfcVertex* v1_LoopVertex) : IfcLoop((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_LoopVertex)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcVertexPoint -IfcPoint* IfcVertexPoint::VertexGeometry() const { return (IfcPoint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcVertexPoint::setVertexGeometry(IfcPoint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcVertexPoint::is(Type::Enum v) const { return v == Type::IfcVertexPoint || IfcVertex::is(v); } -Type::Enum IfcVertexPoint::type() const { return Type::IfcVertexPoint; } +IfcPoint* IfcVertexPoint::VertexGeometry() const { return (IfcPoint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcVertexPoint::setVertexGeometry(IfcPoint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcVertexPoint::declaration() const { return *IfcVertexPoint_type; } Type::Enum IfcVertexPoint::Class() { return Type::IfcVertexPoint; } -IfcVertexPoint::IfcVertexPoint(IfcAbstractEntity* e) : IfcVertex((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVertexPoint)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcVertexPoint::IfcVertexPoint(IfcPoint* v1_VertexGeometry) : IfcVertex((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_VertexGeometry)); entity = e; EntityBuffer::Add(this); } +IfcVertexPoint::IfcVertexPoint(IfcAbstractEntity* e) : IfcVertex((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVertexPoint)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcVertexPoint::IfcVertexPoint(IfcPoint* v1_VertexGeometry) : IfcVertex((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_VertexGeometry)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcVibrationIsolatorType -IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum IfcVibrationIsolatorType::PredefinedType() const { return IfcVibrationIsolatorTypeEnum::FromString(*entity->getArgument(9)); } -void IfcVibrationIsolatorType::setPredefinedType(IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcVibrationIsolatorTypeEnum::ToString(v)); } -bool IfcVibrationIsolatorType::is(Type::Enum v) const { return v == Type::IfcVibrationIsolatorType || IfcDiscreteAccessoryType::is(v); } -Type::Enum IfcVibrationIsolatorType::type() const { return Type::IfcVibrationIsolatorType; } +IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum IfcVibrationIsolatorType::PredefinedType() const { return IfcVibrationIsolatorTypeEnum::FromString(*data_->getArgument(9)); } +void IfcVibrationIsolatorType::setPredefinedType(IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcVibrationIsolatorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcVibrationIsolatorType::declaration() const { return *IfcVibrationIsolatorType_type; } Type::Enum IfcVibrationIsolatorType::Class() { return Type::IfcVibrationIsolatorType; } -IfcVibrationIsolatorType::IfcVibrationIsolatorType(IfcAbstractEntity* e) : IfcDiscreteAccessoryType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVibrationIsolatorType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcVibrationIsolatorType::IfcVibrationIsolatorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum v10_PredefinedType) : IfcDiscreteAccessoryType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcVibrationIsolatorTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcVibrationIsolatorType::IfcVibrationIsolatorType(IfcAbstractEntity* e) : IfcDiscreteAccessoryType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVibrationIsolatorType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcVibrationIsolatorType::IfcVibrationIsolatorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum v10_PredefinedType) : IfcDiscreteAccessoryType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcVibrationIsolatorTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcVirtualElement -bool IfcVirtualElement::is(Type::Enum v) const { return v == Type::IfcVirtualElement || IfcElement::is(v); } -Type::Enum IfcVirtualElement::type() const { return Type::IfcVirtualElement; } + + +const IfcParse::entity& IfcVirtualElement::declaration() const { return *IfcVirtualElement_type; } Type::Enum IfcVirtualElement::Class() { return Type::IfcVirtualElement; } -IfcVirtualElement::IfcVirtualElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVirtualElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcVirtualElement::IfcVirtualElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcVirtualElement::IfcVirtualElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVirtualElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcVirtualElement::IfcVirtualElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcVirtualGridIntersection -IfcTemplatedEntityList< IfcGridAxis >::ptr IfcVirtualGridIntersection::IntersectingAxes() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcVirtualGridIntersection::setIntersectingAxes(IfcTemplatedEntityList< IfcGridAxis >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -std::vector< double > /*[2:3]*/ IfcVirtualGridIntersection::OffsetDistances() const { return *entity->getArgument(1); } -void IfcVirtualGridIntersection::setOffsetDistances(std::vector< double > /*[2:3]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcVirtualGridIntersection::is(Type::Enum v) const { return v == Type::IfcVirtualGridIntersection; } -Type::Enum IfcVirtualGridIntersection::type() const { return Type::IfcVirtualGridIntersection; } +IfcTemplatedEntityList< IfcGridAxis >::ptr IfcVirtualGridIntersection::IntersectingAxes() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcVirtualGridIntersection::setIntersectingAxes(IfcTemplatedEntityList< IfcGridAxis >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } +std::vector< double > /*[2:3]*/ IfcVirtualGridIntersection::OffsetDistances() const { return *data_->getArgument(1); } +void IfcVirtualGridIntersection::setOffsetDistances(std::vector< double > /*[2:3]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcVirtualGridIntersection::declaration() const { return *IfcVirtualGridIntersection_type; } Type::Enum IfcVirtualGridIntersection::Class() { return Type::IfcVirtualGridIntersection; } -IfcVirtualGridIntersection::IfcVirtualGridIntersection(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcVirtualGridIntersection)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcVirtualGridIntersection::IfcVirtualGridIntersection(IfcTemplatedEntityList< IfcGridAxis >::ptr v1_IntersectingAxes, std::vector< double > /*[2:3]*/ v2_OffsetDistances) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_IntersectingAxes)->generalize()); e->setArgument(1,(v2_OffsetDistances)); entity = e; EntityBuffer::Add(this); } +IfcVirtualGridIntersection::IfcVirtualGridIntersection(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcVirtualGridIntersection)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcVirtualGridIntersection::IfcVirtualGridIntersection(IfcTemplatedEntityList< IfcGridAxis >::ptr v1_IntersectingAxes, std::vector< double > /*[2:3]*/ v2_OffsetDistances) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_IntersectingAxes)->generalize()); e->setArgument(1,(v2_OffsetDistances)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWall -bool IfcWall::is(Type::Enum v) const { return v == Type::IfcWall || IfcBuildingElement::is(v); } -Type::Enum IfcWall::type() const { return Type::IfcWall; } + + +const IfcParse::entity& IfcWall::declaration() const { return *IfcWall_type; } Type::Enum IfcWall::Class() { return Type::IfcWall; } -IfcWall::IfcWall(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWall)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWall::IfcWall(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcWall::IfcWall(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWall)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWall::IfcWall(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWallStandardCase -bool IfcWallStandardCase::is(Type::Enum v) const { return v == Type::IfcWallStandardCase || IfcWall::is(v); } -Type::Enum IfcWallStandardCase::type() const { return Type::IfcWallStandardCase; } + + +const IfcParse::entity& IfcWallStandardCase::declaration() const { return *IfcWallStandardCase_type; } Type::Enum IfcWallStandardCase::Class() { return Type::IfcWallStandardCase; } -IfcWallStandardCase::IfcWallStandardCase(IfcAbstractEntity* e) : IfcWall((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWallStandardCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWallStandardCase::IfcWallStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcWall((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcWallStandardCase::IfcWallStandardCase(IfcAbstractEntity* e) : IfcWall((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWallStandardCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWallStandardCase::IfcWallStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcWall((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWallType -IfcWallTypeEnum::IfcWallTypeEnum IfcWallType::PredefinedType() const { return IfcWallTypeEnum::FromString(*entity->getArgument(9)); } -void IfcWallType::setPredefinedType(IfcWallTypeEnum::IfcWallTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcWallTypeEnum::ToString(v)); } -bool IfcWallType::is(Type::Enum v) const { return v == Type::IfcWallType || IfcBuildingElementType::is(v); } -Type::Enum IfcWallType::type() const { return Type::IfcWallType; } +IfcWallTypeEnum::IfcWallTypeEnum IfcWallType::PredefinedType() const { return IfcWallTypeEnum::FromString(*data_->getArgument(9)); } +void IfcWallType::setPredefinedType(IfcWallTypeEnum::IfcWallTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcWallTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcWallType::declaration() const { return *IfcWallType_type; } Type::Enum IfcWallType::Class() { return Type::IfcWallType; } -IfcWallType::IfcWallType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWallType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWallType::IfcWallType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcWallTypeEnum::IfcWallTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcWallTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcWallType::IfcWallType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWallType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWallType::IfcWallType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcWallTypeEnum::IfcWallTypeEnum v10_PredefinedType) : IfcBuildingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcWallTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWasteTerminalType -IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum IfcWasteTerminalType::PredefinedType() const { return IfcWasteTerminalTypeEnum::FromString(*entity->getArgument(9)); } -void IfcWasteTerminalType::setPredefinedType(IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcWasteTerminalTypeEnum::ToString(v)); } -bool IfcWasteTerminalType::is(Type::Enum v) const { return v == Type::IfcWasteTerminalType || IfcFlowTerminalType::is(v); } -Type::Enum IfcWasteTerminalType::type() const { return Type::IfcWasteTerminalType; } +IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum IfcWasteTerminalType::PredefinedType() const { return IfcWasteTerminalTypeEnum::FromString(*data_->getArgument(9)); } +void IfcWasteTerminalType::setPredefinedType(IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcWasteTerminalTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcWasteTerminalType::declaration() const { return *IfcWasteTerminalType_type; } Type::Enum IfcWasteTerminalType::Class() { return Type::IfcWasteTerminalType; } -IfcWasteTerminalType::IfcWasteTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWasteTerminalType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWasteTerminalType::IfcWasteTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcWasteTerminalTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcWasteTerminalType::IfcWasteTerminalType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWasteTerminalType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWasteTerminalType::IfcWasteTerminalType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum v10_PredefinedType) : IfcFlowTerminalType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_ElementType) { e->setArgument(8,(*v9_ElementType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcWasteTerminalTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWaterProperties -bool IfcWaterProperties::hasIsPotable() const { return !entity->getArgument(1)->isNull(); } -bool IfcWaterProperties::IsPotable() const { return *entity->getArgument(1); } -void IfcWaterProperties::setIsPotable(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcWaterProperties::hasHardness() const { return !entity->getArgument(2)->isNull(); } -double IfcWaterProperties::Hardness() const { return *entity->getArgument(2); } -void IfcWaterProperties::setHardness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcWaterProperties::hasAlkalinityConcentration() const { return !entity->getArgument(3)->isNull(); } -double IfcWaterProperties::AlkalinityConcentration() const { return *entity->getArgument(3); } -void IfcWaterProperties::setAlkalinityConcentration(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcWaterProperties::hasAcidityConcentration() const { return !entity->getArgument(4)->isNull(); } -double IfcWaterProperties::AcidityConcentration() const { return *entity->getArgument(4); } -void IfcWaterProperties::setAcidityConcentration(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcWaterProperties::hasImpuritiesContent() const { return !entity->getArgument(5)->isNull(); } -double IfcWaterProperties::ImpuritiesContent() const { return *entity->getArgument(5); } -void IfcWaterProperties::setImpuritiesContent(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcWaterProperties::hasPHLevel() const { return !entity->getArgument(6)->isNull(); } -double IfcWaterProperties::PHLevel() const { return *entity->getArgument(6); } -void IfcWaterProperties::setPHLevel(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcWaterProperties::hasDissolvedSolidsContent() const { return !entity->getArgument(7)->isNull(); } -double IfcWaterProperties::DissolvedSolidsContent() const { return *entity->getArgument(7); } -void IfcWaterProperties::setDissolvedSolidsContent(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcWaterProperties::is(Type::Enum v) const { return v == Type::IfcWaterProperties || IfcMaterialProperties::is(v); } -Type::Enum IfcWaterProperties::type() const { return Type::IfcWaterProperties; } +bool IfcWaterProperties::hasIsPotable() const { return !data_->getArgument(1)->isNull(); } +bool IfcWaterProperties::IsPotable() const { return *data_->getArgument(1); } +void IfcWaterProperties::setIsPotable(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcWaterProperties::hasHardness() const { return !data_->getArgument(2)->isNull(); } +double IfcWaterProperties::Hardness() const { return *data_->getArgument(2); } +void IfcWaterProperties::setHardness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcWaterProperties::hasAlkalinityConcentration() const { return !data_->getArgument(3)->isNull(); } +double IfcWaterProperties::AlkalinityConcentration() const { return *data_->getArgument(3); } +void IfcWaterProperties::setAlkalinityConcentration(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcWaterProperties::hasAcidityConcentration() const { return !data_->getArgument(4)->isNull(); } +double IfcWaterProperties::AcidityConcentration() const { return *data_->getArgument(4); } +void IfcWaterProperties::setAcidityConcentration(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcWaterProperties::hasImpuritiesContent() const { return !data_->getArgument(5)->isNull(); } +double IfcWaterProperties::ImpuritiesContent() const { return *data_->getArgument(5); } +void IfcWaterProperties::setImpuritiesContent(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcWaterProperties::hasPHLevel() const { return !data_->getArgument(6)->isNull(); } +double IfcWaterProperties::PHLevel() const { return *data_->getArgument(6); } +void IfcWaterProperties::setPHLevel(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcWaterProperties::hasDissolvedSolidsContent() const { return !data_->getArgument(7)->isNull(); } +double IfcWaterProperties::DissolvedSolidsContent() const { return *data_->getArgument(7); } +void IfcWaterProperties::setDissolvedSolidsContent(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcWaterProperties::declaration() const { return *IfcWaterProperties_type; } Type::Enum IfcWaterProperties::Class() { return Type::IfcWaterProperties; } -IfcWaterProperties::IfcWaterProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWaterProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWaterProperties::IfcWaterProperties(IfcMaterial* v1_Material, boost::optional< bool > v2_IsPotable, boost::optional< double > v3_Hardness, boost::optional< double > v4_AlkalinityConcentration, boost::optional< double > v5_AcidityConcentration, boost::optional< double > v6_ImpuritiesContent, boost::optional< double > v7_PHLevel, boost::optional< double > v8_DissolvedSolidsContent) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_IsPotable) { e->setArgument(1,(*v2_IsPotable)); } else { e->setArgument(1); } if (v3_Hardness) { e->setArgument(2,(*v3_Hardness)); } else { e->setArgument(2); } if (v4_AlkalinityConcentration) { e->setArgument(3,(*v4_AlkalinityConcentration)); } else { e->setArgument(3); } if (v5_AcidityConcentration) { e->setArgument(4,(*v5_AcidityConcentration)); } else { e->setArgument(4); } if (v6_ImpuritiesContent) { e->setArgument(5,(*v6_ImpuritiesContent)); } else { e->setArgument(5); } if (v7_PHLevel) { e->setArgument(6,(*v7_PHLevel)); } else { e->setArgument(6); } if (v8_DissolvedSolidsContent) { e->setArgument(7,(*v8_DissolvedSolidsContent)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcWaterProperties::IfcWaterProperties(IfcAbstractEntity* e) : IfcMaterialProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWaterProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWaterProperties::IfcWaterProperties(IfcMaterial* v1_Material, boost::optional< bool > v2_IsPotable, boost::optional< double > v3_Hardness, boost::optional< double > v4_AlkalinityConcentration, boost::optional< double > v5_AcidityConcentration, boost::optional< double > v6_ImpuritiesContent, boost::optional< double > v7_PHLevel, boost::optional< double > v8_DissolvedSolidsContent) : IfcMaterialProperties((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Material)); if (v2_IsPotable) { e->setArgument(1,(*v2_IsPotable)); } else { e->setArgument(1); } if (v3_Hardness) { e->setArgument(2,(*v3_Hardness)); } else { e->setArgument(2); } if (v4_AlkalinityConcentration) { e->setArgument(3,(*v4_AlkalinityConcentration)); } else { e->setArgument(3); } if (v5_AcidityConcentration) { e->setArgument(4,(*v5_AcidityConcentration)); } else { e->setArgument(4); } if (v6_ImpuritiesContent) { e->setArgument(5,(*v6_ImpuritiesContent)); } else { e->setArgument(5); } if (v7_PHLevel) { e->setArgument(6,(*v7_PHLevel)); } else { e->setArgument(6); } if (v8_DissolvedSolidsContent) { e->setArgument(7,(*v8_DissolvedSolidsContent)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWindow -bool IfcWindow::hasOverallHeight() const { return !entity->getArgument(8)->isNull(); } -double IfcWindow::OverallHeight() const { return *entity->getArgument(8); } -void IfcWindow::setOverallHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcWindow::hasOverallWidth() const { return !entity->getArgument(9)->isNull(); } -double IfcWindow::OverallWidth() const { return *entity->getArgument(9); } -void IfcWindow::setOverallWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcWindow::is(Type::Enum v) const { return v == Type::IfcWindow || IfcBuildingElement::is(v); } -Type::Enum IfcWindow::type() const { return Type::IfcWindow; } +bool IfcWindow::hasOverallHeight() const { return !data_->getArgument(8)->isNull(); } +double IfcWindow::OverallHeight() const { return *data_->getArgument(8); } +void IfcWindow::setOverallHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcWindow::hasOverallWidth() const { return !data_->getArgument(9)->isNull(); } +double IfcWindow::OverallWidth() const { return *data_->getArgument(9); } +void IfcWindow::setOverallWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +const IfcParse::entity& IfcWindow::declaration() const { return *IfcWindow_type; } Type::Enum IfcWindow::Class() { return Type::IfcWindow; } -IfcWindow::IfcWindow(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindow)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWindow::IfcWindow(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_OverallHeight, boost::optional< double > v10_OverallWidth) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_OverallHeight) { e->setArgument(8,(*v9_OverallHeight)); } else { e->setArgument(8); } if (v10_OverallWidth) { e->setArgument(9,(*v10_OverallWidth)); } else { e->setArgument(9); } entity = e; EntityBuffer::Add(this); } +IfcWindow::IfcWindow(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindow)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWindow::IfcWindow(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_OverallHeight, boost::optional< double > v10_OverallWidth) : IfcBuildingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_ObjectPlacement)); e->setArgument(6,(v7_Representation)); if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } if (v9_OverallHeight) { e->setArgument(8,(*v9_OverallHeight)); } else { e->setArgument(8); } if (v10_OverallWidth) { e->setArgument(9,(*v10_OverallWidth)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWindowLiningProperties -bool IfcWindowLiningProperties::hasLiningDepth() const { return !entity->getArgument(4)->isNull(); } -double IfcWindowLiningProperties::LiningDepth() const { return *entity->getArgument(4); } -void IfcWindowLiningProperties::setLiningDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcWindowLiningProperties::hasLiningThickness() const { return !entity->getArgument(5)->isNull(); } -double IfcWindowLiningProperties::LiningThickness() const { return *entity->getArgument(5); } -void IfcWindowLiningProperties::setLiningThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcWindowLiningProperties::hasTransomThickness() const { return !entity->getArgument(6)->isNull(); } -double IfcWindowLiningProperties::TransomThickness() const { return *entity->getArgument(6); } -void IfcWindowLiningProperties::setTransomThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcWindowLiningProperties::hasMullionThickness() const { return !entity->getArgument(7)->isNull(); } -double IfcWindowLiningProperties::MullionThickness() const { return *entity->getArgument(7); } -void IfcWindowLiningProperties::setMullionThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcWindowLiningProperties::hasFirstTransomOffset() const { return !entity->getArgument(8)->isNull(); } -double IfcWindowLiningProperties::FirstTransomOffset() const { return *entity->getArgument(8); } -void IfcWindowLiningProperties::setFirstTransomOffset(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcWindowLiningProperties::hasSecondTransomOffset() const { return !entity->getArgument(9)->isNull(); } -double IfcWindowLiningProperties::SecondTransomOffset() const { return *entity->getArgument(9); } -void IfcWindowLiningProperties::setSecondTransomOffset(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcWindowLiningProperties::hasFirstMullionOffset() const { return !entity->getArgument(10)->isNull(); } -double IfcWindowLiningProperties::FirstMullionOffset() const { return *entity->getArgument(10); } -void IfcWindowLiningProperties::setFirstMullionOffset(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcWindowLiningProperties::hasSecondMullionOffset() const { return !entity->getArgument(11)->isNull(); } -double IfcWindowLiningProperties::SecondMullionOffset() const { return *entity->getArgument(11); } -void IfcWindowLiningProperties::setSecondMullionOffset(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcWindowLiningProperties::hasShapeAspectStyle() const { return !entity->getArgument(12)->isNull(); } -IfcShapeAspect* IfcWindowLiningProperties::ShapeAspectStyle() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(12))); } -void IfcWindowLiningProperties::setShapeAspectStyle(IfcShapeAspect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcWindowLiningProperties::is(Type::Enum v) const { return v == Type::IfcWindowLiningProperties || IfcPropertySetDefinition::is(v); } -Type::Enum IfcWindowLiningProperties::type() const { return Type::IfcWindowLiningProperties; } +bool IfcWindowLiningProperties::hasLiningDepth() const { return !data_->getArgument(4)->isNull(); } +double IfcWindowLiningProperties::LiningDepth() const { return *data_->getArgument(4); } +void IfcWindowLiningProperties::setLiningDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcWindowLiningProperties::hasLiningThickness() const { return !data_->getArgument(5)->isNull(); } +double IfcWindowLiningProperties::LiningThickness() const { return *data_->getArgument(5); } +void IfcWindowLiningProperties::setLiningThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcWindowLiningProperties::hasTransomThickness() const { return !data_->getArgument(6)->isNull(); } +double IfcWindowLiningProperties::TransomThickness() const { return *data_->getArgument(6); } +void IfcWindowLiningProperties::setTransomThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcWindowLiningProperties::hasMullionThickness() const { return !data_->getArgument(7)->isNull(); } +double IfcWindowLiningProperties::MullionThickness() const { return *data_->getArgument(7); } +void IfcWindowLiningProperties::setMullionThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcWindowLiningProperties::hasFirstTransomOffset() const { return !data_->getArgument(8)->isNull(); } +double IfcWindowLiningProperties::FirstTransomOffset() const { return *data_->getArgument(8); } +void IfcWindowLiningProperties::setFirstTransomOffset(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcWindowLiningProperties::hasSecondTransomOffset() const { return !data_->getArgument(9)->isNull(); } +double IfcWindowLiningProperties::SecondTransomOffset() const { return *data_->getArgument(9); } +void IfcWindowLiningProperties::setSecondTransomOffset(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcWindowLiningProperties::hasFirstMullionOffset() const { return !data_->getArgument(10)->isNull(); } +double IfcWindowLiningProperties::FirstMullionOffset() const { return *data_->getArgument(10); } +void IfcWindowLiningProperties::setFirstMullionOffset(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcWindowLiningProperties::hasSecondMullionOffset() const { return !data_->getArgument(11)->isNull(); } +double IfcWindowLiningProperties::SecondMullionOffset() const { return *data_->getArgument(11); } +void IfcWindowLiningProperties::setSecondMullionOffset(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcWindowLiningProperties::hasShapeAspectStyle() const { return !data_->getArgument(12)->isNull(); } +IfcShapeAspect* IfcWindowLiningProperties::ShapeAspectStyle() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(12))); } +void IfcWindowLiningProperties::setShapeAspectStyle(IfcShapeAspect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } + + +const IfcParse::entity& IfcWindowLiningProperties::declaration() const { return *IfcWindowLiningProperties_type; } Type::Enum IfcWindowLiningProperties::Class() { return Type::IfcWindowLiningProperties; } -IfcWindowLiningProperties::IfcWindowLiningProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindowLiningProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWindowLiningProperties::IfcWindowLiningProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_LiningDepth, boost::optional< double > v6_LiningThickness, boost::optional< double > v7_TransomThickness, boost::optional< double > v8_MullionThickness, boost::optional< double > v9_FirstTransomOffset, boost::optional< double > v10_SecondTransomOffset, boost::optional< double > v11_FirstMullionOffset, boost::optional< double > v12_SecondMullionOffset, IfcShapeAspect* v13_ShapeAspectStyle) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_LiningDepth) { e->setArgument(4,(*v5_LiningDepth)); } else { e->setArgument(4); } if (v6_LiningThickness) { e->setArgument(5,(*v6_LiningThickness)); } else { e->setArgument(5); } if (v7_TransomThickness) { e->setArgument(6,(*v7_TransomThickness)); } else { e->setArgument(6); } if (v8_MullionThickness) { e->setArgument(7,(*v8_MullionThickness)); } else { e->setArgument(7); } if (v9_FirstTransomOffset) { e->setArgument(8,(*v9_FirstTransomOffset)); } else { e->setArgument(8); } if (v10_SecondTransomOffset) { e->setArgument(9,(*v10_SecondTransomOffset)); } else { e->setArgument(9); } if (v11_FirstMullionOffset) { e->setArgument(10,(*v11_FirstMullionOffset)); } else { e->setArgument(10); } if (v12_SecondMullionOffset) { e->setArgument(11,(*v12_SecondMullionOffset)); } else { e->setArgument(11); } e->setArgument(12,(v13_ShapeAspectStyle)); entity = e; EntityBuffer::Add(this); } +IfcWindowLiningProperties::IfcWindowLiningProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindowLiningProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWindowLiningProperties::IfcWindowLiningProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_LiningDepth, boost::optional< double > v6_LiningThickness, boost::optional< double > v7_TransomThickness, boost::optional< double > v8_MullionThickness, boost::optional< double > v9_FirstTransomOffset, boost::optional< double > v10_SecondTransomOffset, boost::optional< double > v11_FirstMullionOffset, boost::optional< double > v12_SecondMullionOffset, IfcShapeAspect* v13_ShapeAspectStyle) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_LiningDepth) { e->setArgument(4,(*v5_LiningDepth)); } else { e->setArgument(4); } if (v6_LiningThickness) { e->setArgument(5,(*v6_LiningThickness)); } else { e->setArgument(5); } if (v7_TransomThickness) { e->setArgument(6,(*v7_TransomThickness)); } else { e->setArgument(6); } if (v8_MullionThickness) { e->setArgument(7,(*v8_MullionThickness)); } else { e->setArgument(7); } if (v9_FirstTransomOffset) { e->setArgument(8,(*v9_FirstTransomOffset)); } else { e->setArgument(8); } if (v10_SecondTransomOffset) { e->setArgument(9,(*v10_SecondTransomOffset)); } else { e->setArgument(9); } if (v11_FirstMullionOffset) { e->setArgument(10,(*v11_FirstMullionOffset)); } else { e->setArgument(10); } if (v12_SecondMullionOffset) { e->setArgument(11,(*v12_SecondMullionOffset)); } else { e->setArgument(11); } e->setArgument(12,(v13_ShapeAspectStyle)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWindowPanelProperties -IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum IfcWindowPanelProperties::OperationType() const { return IfcWindowPanelOperationEnum::FromString(*entity->getArgument(4)); } -void IfcWindowPanelProperties::setOperationType(IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcWindowPanelOperationEnum::ToString(v)); } -IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum IfcWindowPanelProperties::PanelPosition() const { return IfcWindowPanelPositionEnum::FromString(*entity->getArgument(5)); } -void IfcWindowPanelProperties::setPanelPosition(IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcWindowPanelPositionEnum::ToString(v)); } -bool IfcWindowPanelProperties::hasFrameDepth() const { return !entity->getArgument(6)->isNull(); } -double IfcWindowPanelProperties::FrameDepth() const { return *entity->getArgument(6); } -void IfcWindowPanelProperties::setFrameDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcWindowPanelProperties::hasFrameThickness() const { return !entity->getArgument(7)->isNull(); } -double IfcWindowPanelProperties::FrameThickness() const { return *entity->getArgument(7); } -void IfcWindowPanelProperties::setFrameThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcWindowPanelProperties::hasShapeAspectStyle() const { return !entity->getArgument(8)->isNull(); } -IfcShapeAspect* IfcWindowPanelProperties::ShapeAspectStyle() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcWindowPanelProperties::setShapeAspectStyle(IfcShapeAspect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcWindowPanelProperties::is(Type::Enum v) const { return v == Type::IfcWindowPanelProperties || IfcPropertySetDefinition::is(v); } -Type::Enum IfcWindowPanelProperties::type() const { return Type::IfcWindowPanelProperties; } +IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum IfcWindowPanelProperties::OperationType() const { return IfcWindowPanelOperationEnum::FromString(*data_->getArgument(4)); } +void IfcWindowPanelProperties::setOperationType(IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcWindowPanelOperationEnum::ToString(v)); } +IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum IfcWindowPanelProperties::PanelPosition() const { return IfcWindowPanelPositionEnum::FromString(*data_->getArgument(5)); } +void IfcWindowPanelProperties::setPanelPosition(IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcWindowPanelPositionEnum::ToString(v)); } +bool IfcWindowPanelProperties::hasFrameDepth() const { return !data_->getArgument(6)->isNull(); } +double IfcWindowPanelProperties::FrameDepth() const { return *data_->getArgument(6); } +void IfcWindowPanelProperties::setFrameDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcWindowPanelProperties::hasFrameThickness() const { return !data_->getArgument(7)->isNull(); } +double IfcWindowPanelProperties::FrameThickness() const { return *data_->getArgument(7); } +void IfcWindowPanelProperties::setFrameThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcWindowPanelProperties::hasShapeAspectStyle() const { return !data_->getArgument(8)->isNull(); } +IfcShapeAspect* IfcWindowPanelProperties::ShapeAspectStyle() const { return (IfcShapeAspect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcWindowPanelProperties::setShapeAspectStyle(IfcShapeAspect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcWindowPanelProperties::declaration() const { return *IfcWindowPanelProperties_type; } Type::Enum IfcWindowPanelProperties::Class() { return Type::IfcWindowPanelProperties; } -IfcWindowPanelProperties::IfcWindowPanelProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindowPanelProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWindowPanelProperties::IfcWindowPanelProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum v5_OperationType, IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum v6_PanelPosition, boost::optional< double > v7_FrameDepth, boost::optional< double > v8_FrameThickness, IfcShapeAspect* v9_ShapeAspectStyle) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,v5_OperationType,IfcWindowPanelOperationEnum::ToString(v5_OperationType)); e->setArgument(5,v6_PanelPosition,IfcWindowPanelPositionEnum::ToString(v6_PanelPosition)); if (v7_FrameDepth) { e->setArgument(6,(*v7_FrameDepth)); } else { e->setArgument(6); } if (v8_FrameThickness) { e->setArgument(7,(*v8_FrameThickness)); } else { e->setArgument(7); } e->setArgument(8,(v9_ShapeAspectStyle)); entity = e; EntityBuffer::Add(this); } +IfcWindowPanelProperties::IfcWindowPanelProperties(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindowPanelProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWindowPanelProperties::IfcWindowPanelProperties(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum v5_OperationType, IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum v6_PanelPosition, boost::optional< double > v7_FrameDepth, boost::optional< double > v8_FrameThickness, IfcShapeAspect* v9_ShapeAspectStyle) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } e->setArgument(4,v5_OperationType,IfcWindowPanelOperationEnum::ToString(v5_OperationType)); e->setArgument(5,v6_PanelPosition,IfcWindowPanelPositionEnum::ToString(v6_PanelPosition)); if (v7_FrameDepth) { e->setArgument(6,(*v7_FrameDepth)); } else { e->setArgument(6); } if (v8_FrameThickness) { e->setArgument(7,(*v8_FrameThickness)); } else { e->setArgument(7); } e->setArgument(8,(v9_ShapeAspectStyle)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWindowStyle -IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum IfcWindowStyle::ConstructionType() const { return IfcWindowStyleConstructionEnum::FromString(*entity->getArgument(8)); } -void IfcWindowStyle::setConstructionType(IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcWindowStyleConstructionEnum::ToString(v)); } -IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum IfcWindowStyle::OperationType() const { return IfcWindowStyleOperationEnum::FromString(*entity->getArgument(9)); } -void IfcWindowStyle::setOperationType(IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcWindowStyleOperationEnum::ToString(v)); } -bool IfcWindowStyle::ParameterTakesPrecedence() const { return *entity->getArgument(10); } -void IfcWindowStyle::setParameterTakesPrecedence(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcWindowStyle::Sizeable() const { return *entity->getArgument(11); } -void IfcWindowStyle::setSizeable(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcWindowStyle::is(Type::Enum v) const { return v == Type::IfcWindowStyle || IfcTypeProduct::is(v); } -Type::Enum IfcWindowStyle::type() const { return Type::IfcWindowStyle; } +IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum IfcWindowStyle::ConstructionType() const { return IfcWindowStyleConstructionEnum::FromString(*data_->getArgument(8)); } +void IfcWindowStyle::setConstructionType(IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcWindowStyleConstructionEnum::ToString(v)); } +IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum IfcWindowStyle::OperationType() const { return IfcWindowStyleOperationEnum::FromString(*data_->getArgument(9)); } +void IfcWindowStyle::setOperationType(IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcWindowStyleOperationEnum::ToString(v)); } +bool IfcWindowStyle::ParameterTakesPrecedence() const { return *data_->getArgument(10); } +void IfcWindowStyle::setParameterTakesPrecedence(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcWindowStyle::Sizeable() const { return *data_->getArgument(11); } +void IfcWindowStyle::setSizeable(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } + + +const IfcParse::entity& IfcWindowStyle::declaration() const { return *IfcWindowStyle_type; } Type::Enum IfcWindowStyle::Class() { return Type::IfcWindowStyle; } -IfcWindowStyle::IfcWindowStyle(IfcAbstractEntity* e) : IfcTypeProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindowStyle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWindowStyle::IfcWindowStyle(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum v9_ConstructionType, IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum v10_OperationType, bool v11_ParameterTakesPrecedence, bool v12_Sizeable) : IfcTypeProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_ConstructionType,IfcWindowStyleConstructionEnum::ToString(v9_ConstructionType)); e->setArgument(9,v10_OperationType,IfcWindowStyleOperationEnum::ToString(v10_OperationType)); e->setArgument(10,(v11_ParameterTakesPrecedence)); e->setArgument(11,(v12_Sizeable)); entity = e; EntityBuffer::Add(this); } +IfcWindowStyle::IfcWindowStyle(IfcAbstractEntity* e) : IfcTypeProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindowStyle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWindowStyle::IfcWindowStyle(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum v9_ConstructionType, IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum v10_OperationType, bool v11_ParameterTakesPrecedence, bool v12_Sizeable) : IfcTypeProduct((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ApplicableOccurrence) { e->setArgument(4,(*v5_ApplicableOccurrence)); } else { e->setArgument(4); } if (v6_HasPropertySets) { e->setArgument(5,(*v6_HasPropertySets)->generalize()); } else { e->setArgument(5); } if (v7_RepresentationMaps) { e->setArgument(6,(*v7_RepresentationMaps)->generalize()); } else { e->setArgument(6); } if (v8_Tag) { e->setArgument(7,(*v8_Tag)); } else { e->setArgument(7); } e->setArgument(8,v9_ConstructionType,IfcWindowStyleConstructionEnum::ToString(v9_ConstructionType)); e->setArgument(9,v10_OperationType,IfcWindowStyleOperationEnum::ToString(v10_OperationType)); e->setArgument(10,(v11_ParameterTakesPrecedence)); e->setArgument(11,(v12_Sizeable)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWorkControl -std::string IfcWorkControl::Identifier() const { return *entity->getArgument(5); } -void IfcWorkControl::setIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcDateTimeSelect* IfcWorkControl::CreationDate() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcWorkControl::setCreationDate(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcWorkControl::hasCreators() const { return !entity->getArgument(7)->isNull(); } -IfcTemplatedEntityList< IfcPerson >::ptr IfcWorkControl::Creators() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcWorkControl::setCreators(IfcTemplatedEntityList< IfcPerson >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -bool IfcWorkControl::hasPurpose() const { return !entity->getArgument(8)->isNull(); } -std::string IfcWorkControl::Purpose() const { return *entity->getArgument(8); } -void IfcWorkControl::setPurpose(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcWorkControl::hasDuration() const { return !entity->getArgument(9)->isNull(); } -double IfcWorkControl::Duration() const { return *entity->getArgument(9); } -void IfcWorkControl::setDuration(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcWorkControl::hasTotalFloat() const { return !entity->getArgument(10)->isNull(); } -double IfcWorkControl::TotalFloat() const { return *entity->getArgument(10); } -void IfcWorkControl::setTotalFloat(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -IfcDateTimeSelect* IfcWorkControl::StartTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(11))); } -void IfcWorkControl::setStartTime(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcWorkControl::hasFinishTime() const { return !entity->getArgument(12)->isNull(); } -IfcDateTimeSelect* IfcWorkControl::FinishTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(12))); } -void IfcWorkControl::setFinishTime(IfcDateTimeSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcWorkControl::hasWorkControlType() const { return !entity->getArgument(13)->isNull(); } -IfcWorkControlTypeEnum::IfcWorkControlTypeEnum IfcWorkControl::WorkControlType() const { return IfcWorkControlTypeEnum::FromString(*entity->getArgument(13)); } -void IfcWorkControl::setWorkControlType(IfcWorkControlTypeEnum::IfcWorkControlTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v,IfcWorkControlTypeEnum::ToString(v)); } -bool IfcWorkControl::hasUserDefinedControlType() const { return !entity->getArgument(14)->isNull(); } -std::string IfcWorkControl::UserDefinedControlType() const { return *entity->getArgument(14); } -void IfcWorkControl::setUserDefinedControlType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcWorkControl::is(Type::Enum v) const { return v == Type::IfcWorkControl || IfcControl::is(v); } -Type::Enum IfcWorkControl::type() const { return Type::IfcWorkControl; } +std::string IfcWorkControl::Identifier() const { return *data_->getArgument(5); } +void IfcWorkControl::setIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +IfcDateTimeSelect* IfcWorkControl::CreationDate() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcWorkControl::setCreationDate(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcWorkControl::hasCreators() const { return !data_->getArgument(7)->isNull(); } +IfcTemplatedEntityList< IfcPerson >::ptr IfcWorkControl::Creators() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcWorkControl::setCreators(IfcTemplatedEntityList< IfcPerson >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } +bool IfcWorkControl::hasPurpose() const { return !data_->getArgument(8)->isNull(); } +std::string IfcWorkControl::Purpose() const { return *data_->getArgument(8); } +void IfcWorkControl::setPurpose(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcWorkControl::hasDuration() const { return !data_->getArgument(9)->isNull(); } +double IfcWorkControl::Duration() const { return *data_->getArgument(9); } +void IfcWorkControl::setDuration(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcWorkControl::hasTotalFloat() const { return !data_->getArgument(10)->isNull(); } +double IfcWorkControl::TotalFloat() const { return *data_->getArgument(10); } +void IfcWorkControl::setTotalFloat(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +IfcDateTimeSelect* IfcWorkControl::StartTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(11))); } +void IfcWorkControl::setStartTime(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcWorkControl::hasFinishTime() const { return !data_->getArgument(12)->isNull(); } +IfcDateTimeSelect* IfcWorkControl::FinishTime() const { return (IfcDateTimeSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(12))); } +void IfcWorkControl::setFinishTime(IfcDateTimeSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcWorkControl::hasWorkControlType() const { return !data_->getArgument(13)->isNull(); } +IfcWorkControlTypeEnum::IfcWorkControlTypeEnum IfcWorkControl::WorkControlType() const { return IfcWorkControlTypeEnum::FromString(*data_->getArgument(13)); } +void IfcWorkControl::setWorkControlType(IfcWorkControlTypeEnum::IfcWorkControlTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v,IfcWorkControlTypeEnum::ToString(v)); } +bool IfcWorkControl::hasUserDefinedControlType() const { return !data_->getArgument(14)->isNull(); } +std::string IfcWorkControl::UserDefinedControlType() const { return *data_->getArgument(14); } +void IfcWorkControl::setUserDefinedControlType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } + + +const IfcParse::entity& IfcWorkControl::declaration() const { return *IfcWorkControl_type; } Type::Enum IfcWorkControl::Class() { return Type::IfcWorkControl; } -IfcWorkControl::IfcWorkControl(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWorkControl)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWorkControl::IfcWorkControl(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, IfcDateTimeSelect* v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, IfcDateTimeSelect* v12_StartTime, IfcDateTimeSelect* v13_FinishTime, boost::optional< IfcWorkControlTypeEnum::IfcWorkControlTypeEnum > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_Identifier)); e->setArgument(6,(v7_CreationDate)); if (v8_Creators) { e->setArgument(7,(*v8_Creators)->generalize()); } else { e->setArgument(7); } if (v9_Purpose) { e->setArgument(8,(*v9_Purpose)); } else { e->setArgument(8); } if (v10_Duration) { e->setArgument(9,(*v10_Duration)); } else { e->setArgument(9); } if (v11_TotalFloat) { e->setArgument(10,(*v11_TotalFloat)); } else { e->setArgument(10); } e->setArgument(11,(v12_StartTime)); e->setArgument(12,(v13_FinishTime)); if (v14_WorkControlType) { e->setArgument(13,*v14_WorkControlType,IfcWorkControlTypeEnum::ToString(*v14_WorkControlType)); } else { e->setArgument(13); } if (v15_UserDefinedControlType) { e->setArgument(14,(*v15_UserDefinedControlType)); } else { e->setArgument(14); } entity = e; EntityBuffer::Add(this); } +IfcWorkControl::IfcWorkControl(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWorkControl)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWorkControl::IfcWorkControl(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, IfcDateTimeSelect* v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, IfcDateTimeSelect* v12_StartTime, IfcDateTimeSelect* v13_FinishTime, boost::optional< IfcWorkControlTypeEnum::IfcWorkControlTypeEnum > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType) : IfcControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_Identifier)); e->setArgument(6,(v7_CreationDate)); if (v8_Creators) { e->setArgument(7,(*v8_Creators)->generalize()); } else { e->setArgument(7); } if (v9_Purpose) { e->setArgument(8,(*v9_Purpose)); } else { e->setArgument(8); } if (v10_Duration) { e->setArgument(9,(*v10_Duration)); } else { e->setArgument(9); } if (v11_TotalFloat) { e->setArgument(10,(*v11_TotalFloat)); } else { e->setArgument(10); } e->setArgument(11,(v12_StartTime)); e->setArgument(12,(v13_FinishTime)); if (v14_WorkControlType) { e->setArgument(13,*v14_WorkControlType,IfcWorkControlTypeEnum::ToString(*v14_WorkControlType)); } else { e->setArgument(13); } if (v15_UserDefinedControlType) { e->setArgument(14,(*v15_UserDefinedControlType)); } else { e->setArgument(14); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWorkPlan -bool IfcWorkPlan::is(Type::Enum v) const { return v == Type::IfcWorkPlan || IfcWorkControl::is(v); } -Type::Enum IfcWorkPlan::type() const { return Type::IfcWorkPlan; } + + +const IfcParse::entity& IfcWorkPlan::declaration() const { return *IfcWorkPlan_type; } Type::Enum IfcWorkPlan::Class() { return Type::IfcWorkPlan; } -IfcWorkPlan::IfcWorkPlan(IfcAbstractEntity* e) : IfcWorkControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWorkPlan)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWorkPlan::IfcWorkPlan(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, IfcDateTimeSelect* v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, IfcDateTimeSelect* v12_StartTime, IfcDateTimeSelect* v13_FinishTime, boost::optional< IfcWorkControlTypeEnum::IfcWorkControlTypeEnum > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType) : IfcWorkControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_Identifier)); e->setArgument(6,(v7_CreationDate)); if (v8_Creators) { e->setArgument(7,(*v8_Creators)->generalize()); } else { e->setArgument(7); } if (v9_Purpose) { e->setArgument(8,(*v9_Purpose)); } else { e->setArgument(8); } if (v10_Duration) { e->setArgument(9,(*v10_Duration)); } else { e->setArgument(9); } if (v11_TotalFloat) { e->setArgument(10,(*v11_TotalFloat)); } else { e->setArgument(10); } e->setArgument(11,(v12_StartTime)); e->setArgument(12,(v13_FinishTime)); if (v14_WorkControlType) { e->setArgument(13,*v14_WorkControlType,IfcWorkControlTypeEnum::ToString(*v14_WorkControlType)); } else { e->setArgument(13); } if (v15_UserDefinedControlType) { e->setArgument(14,(*v15_UserDefinedControlType)); } else { e->setArgument(14); } entity = e; EntityBuffer::Add(this); } +IfcWorkPlan::IfcWorkPlan(IfcAbstractEntity* e) : IfcWorkControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWorkPlan)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWorkPlan::IfcWorkPlan(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, IfcDateTimeSelect* v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, IfcDateTimeSelect* v12_StartTime, IfcDateTimeSelect* v13_FinishTime, boost::optional< IfcWorkControlTypeEnum::IfcWorkControlTypeEnum > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType) : IfcWorkControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_Identifier)); e->setArgument(6,(v7_CreationDate)); if (v8_Creators) { e->setArgument(7,(*v8_Creators)->generalize()); } else { e->setArgument(7); } if (v9_Purpose) { e->setArgument(8,(*v9_Purpose)); } else { e->setArgument(8); } if (v10_Duration) { e->setArgument(9,(*v10_Duration)); } else { e->setArgument(9); } if (v11_TotalFloat) { e->setArgument(10,(*v11_TotalFloat)); } else { e->setArgument(10); } e->setArgument(11,(v12_StartTime)); e->setArgument(12,(v13_FinishTime)); if (v14_WorkControlType) { e->setArgument(13,*v14_WorkControlType,IfcWorkControlTypeEnum::ToString(*v14_WorkControlType)); } else { e->setArgument(13); } if (v15_UserDefinedControlType) { e->setArgument(14,(*v15_UserDefinedControlType)); } else { e->setArgument(14); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWorkSchedule -bool IfcWorkSchedule::is(Type::Enum v) const { return v == Type::IfcWorkSchedule || IfcWorkControl::is(v); } -Type::Enum IfcWorkSchedule::type() const { return Type::IfcWorkSchedule; } + + +const IfcParse::entity& IfcWorkSchedule::declaration() const { return *IfcWorkSchedule_type; } Type::Enum IfcWorkSchedule::Class() { return Type::IfcWorkSchedule; } -IfcWorkSchedule::IfcWorkSchedule(IfcAbstractEntity* e) : IfcWorkControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWorkSchedule)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWorkSchedule::IfcWorkSchedule(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, IfcDateTimeSelect* v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, IfcDateTimeSelect* v12_StartTime, IfcDateTimeSelect* v13_FinishTime, boost::optional< IfcWorkControlTypeEnum::IfcWorkControlTypeEnum > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType) : IfcWorkControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_Identifier)); e->setArgument(6,(v7_CreationDate)); if (v8_Creators) { e->setArgument(7,(*v8_Creators)->generalize()); } else { e->setArgument(7); } if (v9_Purpose) { e->setArgument(8,(*v9_Purpose)); } else { e->setArgument(8); } if (v10_Duration) { e->setArgument(9,(*v10_Duration)); } else { e->setArgument(9); } if (v11_TotalFloat) { e->setArgument(10,(*v11_TotalFloat)); } else { e->setArgument(10); } e->setArgument(11,(v12_StartTime)); e->setArgument(12,(v13_FinishTime)); if (v14_WorkControlType) { e->setArgument(13,*v14_WorkControlType,IfcWorkControlTypeEnum::ToString(*v14_WorkControlType)); } else { e->setArgument(13); } if (v15_UserDefinedControlType) { e->setArgument(14,(*v15_UserDefinedControlType)); } else { e->setArgument(14); } entity = e; EntityBuffer::Add(this); } +IfcWorkSchedule::IfcWorkSchedule(IfcAbstractEntity* e) : IfcWorkControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWorkSchedule)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWorkSchedule::IfcWorkSchedule(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, IfcDateTimeSelect* v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, IfcDateTimeSelect* v12_StartTime, IfcDateTimeSelect* v13_FinishTime, boost::optional< IfcWorkControlTypeEnum::IfcWorkControlTypeEnum > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType) : IfcWorkControl((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } e->setArgument(5,(v6_Identifier)); e->setArgument(6,(v7_CreationDate)); if (v8_Creators) { e->setArgument(7,(*v8_Creators)->generalize()); } else { e->setArgument(7); } if (v9_Purpose) { e->setArgument(8,(*v9_Purpose)); } else { e->setArgument(8); } if (v10_Duration) { e->setArgument(9,(*v10_Duration)); } else { e->setArgument(9); } if (v11_TotalFloat) { e->setArgument(10,(*v11_TotalFloat)); } else { e->setArgument(10); } e->setArgument(11,(v12_StartTime)); e->setArgument(12,(v13_FinishTime)); if (v14_WorkControlType) { e->setArgument(13,*v14_WorkControlType,IfcWorkControlTypeEnum::ToString(*v14_WorkControlType)); } else { e->setArgument(13); } if (v15_UserDefinedControlType) { e->setArgument(14,(*v15_UserDefinedControlType)); } else { e->setArgument(14); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcZShapeProfileDef -double IfcZShapeProfileDef::Depth() const { return *entity->getArgument(3); } -void IfcZShapeProfileDef::setDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcZShapeProfileDef::FlangeWidth() const { return *entity->getArgument(4); } -void IfcZShapeProfileDef::setFlangeWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -double IfcZShapeProfileDef::WebThickness() const { return *entity->getArgument(5); } -void IfcZShapeProfileDef::setWebThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcZShapeProfileDef::FlangeThickness() const { return *entity->getArgument(6); } -void IfcZShapeProfileDef::setFlangeThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcZShapeProfileDef::hasFilletRadius() const { return !entity->getArgument(7)->isNull(); } -double IfcZShapeProfileDef::FilletRadius() const { return *entity->getArgument(7); } -void IfcZShapeProfileDef::setFilletRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcZShapeProfileDef::hasEdgeRadius() const { return !entity->getArgument(8)->isNull(); } -double IfcZShapeProfileDef::EdgeRadius() const { return *entity->getArgument(8); } -void IfcZShapeProfileDef::setEdgeRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcZShapeProfileDef::is(Type::Enum v) const { return v == Type::IfcZShapeProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcZShapeProfileDef::type() const { return Type::IfcZShapeProfileDef; } +double IfcZShapeProfileDef::Depth() const { return *data_->getArgument(3); } +void IfcZShapeProfileDef::setDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcZShapeProfileDef::FlangeWidth() const { return *data_->getArgument(4); } +void IfcZShapeProfileDef::setFlangeWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +double IfcZShapeProfileDef::WebThickness() const { return *data_->getArgument(5); } +void IfcZShapeProfileDef::setWebThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcZShapeProfileDef::FlangeThickness() const { return *data_->getArgument(6); } +void IfcZShapeProfileDef::setFlangeThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcZShapeProfileDef::hasFilletRadius() const { return !data_->getArgument(7)->isNull(); } +double IfcZShapeProfileDef::FilletRadius() const { return *data_->getArgument(7); } +void IfcZShapeProfileDef::setFilletRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcZShapeProfileDef::hasEdgeRadius() const { return !data_->getArgument(8)->isNull(); } +double IfcZShapeProfileDef::EdgeRadius() const { return *data_->getArgument(8); } +void IfcZShapeProfileDef::setEdgeRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcZShapeProfileDef::declaration() const { return *IfcZShapeProfileDef_type; } Type::Enum IfcZShapeProfileDef::Class() { return Type::IfcZShapeProfileDef; } -IfcZShapeProfileDef::IfcZShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcZShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcZShapeProfileDef::IfcZShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_EdgeRadius) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Depth)); e->setArgument(4,(v5_FlangeWidth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_FlangeThickness)); if (v8_FilletRadius) { e->setArgument(7,(*v8_FilletRadius)); } else { e->setArgument(7); } if (v9_EdgeRadius) { e->setArgument(8,(*v9_EdgeRadius)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcZShapeProfileDef::IfcZShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcZShapeProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcZShapeProfileDef::IfcZShapeProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_EdgeRadius) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_Depth)); e->setArgument(4,(v5_FlangeWidth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_FlangeThickness)); if (v8_FilletRadius) { e->setArgument(7,(*v8_FilletRadius)); } else { e->setArgument(7); } if (v9_EdgeRadius) { e->setArgument(8,(*v9_EdgeRadius)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcZone -bool IfcZone::is(Type::Enum v) const { return v == Type::IfcZone || IfcGroup::is(v); } -Type::Enum IfcZone::type() const { return Type::IfcZone; } + + +const IfcParse::entity& IfcZone::declaration() const { return *IfcZone_type; } Type::Enum IfcZone::Class() { return Type::IfcZone; } -IfcZone::IfcZone(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcZone)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcZone::IfcZone(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcZone::IfcZone(IfcAbstractEntity* e) : IfcGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcZone)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcZone::IfcZone(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } #endif diff --git a/src/ifcparse/Ifc2x3.h b/src/ifcparse/Ifc2x3.h index 963ae54e08..39286420c9 100644 --- a/src/ifcparse/Ifc2x3.h +++ b/src/ifcparse/Ifc2x3.h @@ -34,9 +34,12 @@ #include #include "../ifcparse/IfcUtil.h" +#include "../ifcparse/IfcSchema.h" #include "../ifcparse/IfcException.h" #include "../ifcparse/Ifc2x3enum.h" +const IfcParse::schema_definition& get_schema(); + #define IfcSchema Ifc2x3 namespace Ifc2x3 { @@ -4445,10 +4448,7 @@ IfcWorkControlTypeEnum FromString(const std::string& s); /// HISTORY New type in IFC Release 2x. class IfcAbsorbedDoseMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcAbsorbedDoseMeasure (IfcAbstractEntity* e); IfcAbsorbedDoseMeasure (double v); @@ -4461,10 +4461,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcAccelerationMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcAccelerationMeasure (IfcAbstractEntity* e); IfcAccelerationMeasure (double v); @@ -4480,10 +4477,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcAmountOfSubstanceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcAmountOfSubstanceMeasure (IfcAbstractEntity* e); IfcAmountOfSubstanceMeasure (double v); @@ -4496,10 +4490,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcAngularVelocityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcAngularVelocityMeasure (IfcAbstractEntity* e); IfcAngularVelocityMeasure (double v); @@ -4514,10 +4505,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcAreaMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcAreaMeasure (IfcAbstractEntity* e); IfcAreaMeasure (double v); @@ -4530,10 +4518,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcBoolean : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcBoolean (IfcAbstractEntity* e); IfcBoolean (bool v); @@ -4552,10 +4537,7 @@ public: /// HISTORY New type in IFC Release 2x2. class IfcComplexNumber : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcComplexNumber (IfcAbstractEntity* e); IfcComplexNumber (std::vector< double > /*[1:2]*/ v); @@ -4611,10 +4593,7 @@ public: /// Another often encountered display format of latitudes and longitudes is to omit the signs and print N, S, E, W indicators instead, for example, 50°58'33"S. When stored as IfcCompoundPlaneAngleMeasure however, a compound plane angle measure is always signed, with same sign of all components. class IfcCompoundPlaneAngleMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcCompoundPlaneAngleMeasure (IfcAbstractEntity* e); IfcCompoundPlaneAngleMeasure (std::vector< int > /*[3:4]*/ v); @@ -4628,10 +4607,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcContextDependentMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcContextDependentMeasure (IfcAbstractEntity* e); IfcContextDependentMeasure (double v); @@ -4645,10 +4621,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcCountMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcCountMeasure (IfcAbstractEntity* e); IfcCountMeasure (double v); @@ -4663,10 +4636,7 @@ public: /// HISTORY New type in IFC2x2. class IfcCurvatureMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcCurvatureMeasure (IfcAbstractEntity* e); IfcCurvatureMeasure (double v); @@ -4686,10 +4656,7 @@ public: /// ValidRange added. class IfcDayInMonthNumber : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcDayInMonthNumber (IfcAbstractEntity* e); IfcDayInMonthNumber (int v); @@ -4698,10 +4665,7 @@ public: class IfcDaylightSavingHour : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcDaylightSavingHour (IfcAbstractEntity* e); IfcDaylightSavingHour (int v); @@ -4715,10 +4679,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcDescriptiveMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcDescriptiveMeasure (IfcAbstractEntity* e); IfcDescriptiveMeasure (std::string v); @@ -4733,10 +4694,7 @@ public: /// HISTORY New Type in IFC Release 1.5 class IfcDimensionCount : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcDimensionCount (IfcAbstractEntity* e); IfcDimensionCount (int v); @@ -4749,10 +4707,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcDoseEquivalentMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcDoseEquivalentMeasure (IfcAbstractEntity* e); IfcDoseEquivalentMeasure (double v); @@ -4766,10 +4721,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcDynamicViscosityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcDynamicViscosityMeasure (IfcAbstractEntity* e); IfcDynamicViscosityMeasure (double v); @@ -4782,10 +4734,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcElectricCapacitanceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcElectricCapacitanceMeasure (IfcAbstractEntity* e); IfcElectricCapacitanceMeasure (double v); @@ -4798,10 +4747,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcElectricChargeMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcElectricChargeMeasure (IfcAbstractEntity* e); IfcElectricChargeMeasure (double v); @@ -4814,10 +4760,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcElectricConductanceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcElectricConductanceMeasure (IfcAbstractEntity* e); IfcElectricConductanceMeasure (double v); @@ -4832,10 +4775,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcElectricCurrentMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcElectricCurrentMeasure (IfcAbstractEntity* e); IfcElectricCurrentMeasure (double v); @@ -4848,10 +4788,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcElectricResistanceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcElectricResistanceMeasure (IfcAbstractEntity* e); IfcElectricResistanceMeasure (double v); @@ -4864,10 +4801,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcElectricVoltageMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcElectricVoltageMeasure (IfcAbstractEntity* e); IfcElectricVoltageMeasure (double v); @@ -4880,10 +4814,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcEnergyMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcEnergyMeasure (IfcAbstractEntity* e); IfcEnergyMeasure (double v); @@ -4905,10 +4836,7 @@ public: /// HISTORY  New type in IFC2x3. class IfcFontStyle : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcFontStyle (IfcAbstractEntity* e); IfcFontStyle (std::string v); @@ -4928,10 +4856,7 @@ public: /// HISTORY  New type in IFC2x3. class IfcFontVariant : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcFontVariant (IfcAbstractEntity* e); IfcFontVariant (std::string v); @@ -4962,10 +4887,7 @@ public: /// HISTORY  New type in IFC2x2 Addendum 2. class IfcFontWeight : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcFontWeight (IfcAbstractEntity* e); IfcFontWeight (std::string v); @@ -4978,10 +4900,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcForceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcForceMeasure (IfcAbstractEntity* e); IfcForceMeasure (double v); @@ -4994,10 +4913,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcFrequencyMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcFrequencyMeasure (IfcAbstractEntity* e); IfcFrequencyMeasure (double v); @@ -5020,10 +4936,7 @@ public: /// HISTORY  New type in IFC R1.5.1. class IfcGloballyUniqueId : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcGloballyUniqueId (IfcAbstractEntity* e); IfcGloballyUniqueId (std::string v); @@ -5036,10 +4949,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcHeatFluxDensityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcHeatFluxDensityMeasure (IfcAbstractEntity* e); IfcHeatFluxDensityMeasure (double v); @@ -5050,10 +4960,7 @@ public: /// HISTORY: This is new type in IFC2x2. class IfcHeatingValueMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcHeatingValueMeasure (IfcAbstractEntity* e); IfcHeatingValueMeasure (double v); @@ -5062,10 +4969,7 @@ public: class IfcHourInDay : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcHourInDay (IfcAbstractEntity* e); IfcHourInDay (int v); @@ -5087,10 +4991,7 @@ public: /// Note that while IfcIdentifier is restricted to 255 characters, the size in exchange files after encoding may be considerably larger than 255 octets, depending on the particular encoding and on the contents of the identifier. class IfcIdentifier : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcIdentifier (IfcAbstractEntity* e); IfcIdentifier (std::string v); @@ -5103,10 +5004,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcIlluminanceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcIlluminanceMeasure (IfcAbstractEntity* e); IfcIlluminanceMeasure (double v); @@ -5119,10 +5017,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcInductanceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcInductanceMeasure (IfcAbstractEntity* e); IfcInductanceMeasure (double v); @@ -5137,10 +5032,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcInteger : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcInteger (IfcAbstractEntity* e); IfcInteger (int v); @@ -5155,10 +5047,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcIntegerCountRateMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcIntegerCountRateMeasure (IfcAbstractEntity* e); IfcIntegerCountRateMeasure (int v); @@ -5169,10 +5058,7 @@ public: /// HISTORY: New type in IFC2x2. class IfcIonConcentrationMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcIonConcentrationMeasure (IfcAbstractEntity* e); IfcIonConcentrationMeasure (double v); @@ -5185,10 +5071,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcIsothermalMoistureCapacityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcIsothermalMoistureCapacityMeasure (IfcAbstractEntity* e); IfcIsothermalMoistureCapacityMeasure (double v); @@ -5201,10 +5084,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcKinematicViscosityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcKinematicViscosityMeasure (IfcAbstractEntity* e); IfcKinematicViscosityMeasure (double v); @@ -5226,10 +5106,7 @@ public: /// Note that while IfcLabel is restricted to 255 characters, the size in exchange files after encoding may be considerably larger than 255 octets, depending on the particular encoding and on the contents of the label. class IfcLabel : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcLabel (IfcAbstractEntity* e); IfcLabel (std::string v); @@ -5244,10 +5121,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcLengthMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcLengthMeasure (IfcAbstractEntity* e); IfcLengthMeasure (double v); @@ -5260,10 +5134,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcLinearForceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcLinearForceMeasure (IfcAbstractEntity* e); IfcLinearForceMeasure (double v); @@ -5276,10 +5147,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcLinearMomentMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcLinearMomentMeasure (IfcAbstractEntity* e); IfcLinearMomentMeasure (double v); @@ -5292,10 +5160,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcLinearStiffnessMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcLinearStiffnessMeasure (IfcAbstractEntity* e); IfcLinearStiffnessMeasure (double v); @@ -5308,10 +5173,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcLinearVelocityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcLinearVelocityMeasure (IfcAbstractEntity* e); IfcLinearVelocityMeasure (double v); @@ -5324,10 +5186,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcLogical : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcLogical (IfcAbstractEntity* e); IfcLogical (bool v); @@ -5340,10 +5199,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcLuminousFluxMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcLuminousFluxMeasure (IfcAbstractEntity* e); IfcLuminousFluxMeasure (double v); @@ -5358,10 +5214,7 @@ public: /// HISTORY New type in IFC2x2. class IfcLuminousIntensityDistributionMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcLuminousIntensityDistributionMeasure (IfcAbstractEntity* e); IfcLuminousIntensityDistributionMeasure (double v); @@ -5376,10 +5229,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcLuminousIntensityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcLuminousIntensityMeasure (IfcAbstractEntity* e); IfcLuminousIntensityMeasure (double v); @@ -5392,10 +5242,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcMagneticFluxDensityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMagneticFluxDensityMeasure (IfcAbstractEntity* e); IfcMagneticFluxDensityMeasure (double v); @@ -5408,10 +5255,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcMagneticFluxMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMagneticFluxMeasure (IfcAbstractEntity* e); IfcMagneticFluxMeasure (double v); @@ -5424,10 +5268,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcMassDensityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMassDensityMeasure (IfcAbstractEntity* e); IfcMassDensityMeasure (double v); @@ -5440,10 +5281,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcMassFlowRateMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMassFlowRateMeasure (IfcAbstractEntity* e); IfcMassFlowRateMeasure (double v); @@ -5458,10 +5296,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcMassMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMassMeasure (IfcAbstractEntity* e); IfcMassMeasure (double v); @@ -5476,10 +5311,7 @@ public: /// HISTORY New type in IFC2x2. class IfcMassPerLengthMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMassPerLengthMeasure (IfcAbstractEntity* e); IfcMassPerLengthMeasure (double v); @@ -5488,10 +5320,7 @@ public: class IfcMinuteInHour : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMinuteInHour (IfcAbstractEntity* e); IfcMinuteInHour (int v); @@ -5504,10 +5333,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcModulusOfElasticityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcModulusOfElasticityMeasure (IfcAbstractEntity* e); IfcModulusOfElasticityMeasure (double v); @@ -5520,10 +5346,7 @@ public: /// HISTORY New type in IFC Release 2x2. class IfcModulusOfLinearSubgradeReactionMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcModulusOfLinearSubgradeReactionMeasure (IfcAbstractEntity* e); IfcModulusOfLinearSubgradeReactionMeasure (double v); @@ -5536,10 +5359,7 @@ public: /// HISTORY New type in IFC2x2. class IfcModulusOfRotationalSubgradeReactionMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcModulusOfRotationalSubgradeReactionMeasure (IfcAbstractEntity* e); IfcModulusOfRotationalSubgradeReactionMeasure (double v); @@ -5556,10 +5376,7 @@ public: /// Figure 290 — Modulus of subgrade reaction measure class IfcModulusOfSubgradeReactionMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcModulusOfSubgradeReactionMeasure (IfcAbstractEntity* e); IfcModulusOfSubgradeReactionMeasure (double v); @@ -5572,10 +5389,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcMoistureDiffusivityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMoistureDiffusivityMeasure (IfcAbstractEntity* e); IfcMoistureDiffusivityMeasure (double v); @@ -5588,10 +5402,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcMolecularWeightMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMolecularWeightMeasure (IfcAbstractEntity* e); IfcMolecularWeightMeasure (double v); @@ -5604,10 +5415,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcMomentOfInertiaMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMomentOfInertiaMeasure (IfcAbstractEntity* e); IfcMomentOfInertiaMeasure (double v); @@ -5619,10 +5427,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcMonetaryMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMonetaryMeasure (IfcAbstractEntity* e); IfcMonetaryMeasure (double v); @@ -5686,10 +5491,7 @@ public: /// Release 1.5.1. class IfcMonthInYearNumber : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcMonthInYearNumber (IfcAbstractEntity* e); IfcMonthInYearNumber (int v); @@ -5703,10 +5505,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcNumericMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcNumericMeasure (IfcAbstractEntity* e); IfcNumericMeasure (double v); @@ -5717,10 +5516,7 @@ public: /// HISTORY: New type in IFC 2x2. class IfcPHMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcPHMeasure (IfcAbstractEntity* e); IfcPHMeasure (double v); @@ -5735,10 +5531,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcParameterValue : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcParameterValue (IfcAbstractEntity* e); IfcParameterValue (double v); @@ -5751,10 +5544,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcPlanarForceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcPlanarForceMeasure (IfcAbstractEntity* e); IfcPlanarForceMeasure (double v); @@ -5773,10 +5563,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcPlaneAngleMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcPlaneAngleMeasure (IfcAbstractEntity* e); IfcPlaneAngleMeasure (double v); @@ -5790,10 +5577,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcPositiveLengthMeasure : public IfcLengthMeasure { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcPositiveLengthMeasure (IfcAbstractEntity* e); IfcPositiveLengthMeasure (double v); @@ -5807,10 +5591,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcPositivePlaneAngleMeasure : public IfcPlaneAngleMeasure { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcPositivePlaneAngleMeasure (IfcAbstractEntity* e); IfcPositivePlaneAngleMeasure (double v); @@ -5823,10 +5604,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcPowerMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcPowerMeasure (IfcAbstractEntity* e); IfcPowerMeasure (double v); @@ -5843,10 +5621,7 @@ public: /// HISTORY  New type in IFC2x2. class IfcPresentableText : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcPresentableText (IfcAbstractEntity* e); IfcPresentableText (std::string v); @@ -5859,10 +5634,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcPressureMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcPressureMeasure (IfcAbstractEntity* e); IfcPressureMeasure (double v); @@ -5875,10 +5647,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcRadioActivityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcRadioActivityMeasure (IfcAbstractEntity* e); IfcRadioActivityMeasure (double v); @@ -5896,10 +5665,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcRatioMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcRatioMeasure (IfcAbstractEntity* e); IfcRatioMeasure (double v); @@ -5914,10 +5680,7 @@ public: /// HISTORY: New type in IFC Release 1.5.1. class IfcReal : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcReal (IfcAbstractEntity* e); IfcReal (double v); @@ -5930,10 +5693,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcRotationalFrequencyMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcRotationalFrequencyMeasure (IfcAbstractEntity* e); IfcRotationalFrequencyMeasure (double v); @@ -5947,10 +5707,7 @@ public: /// HISTORY New type in IFC2x2. class IfcRotationalMassMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcRotationalMassMeasure (IfcAbstractEntity* e); IfcRotationalMassMeasure (double v); @@ -5963,10 +5720,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcRotationalStiffnessMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcRotationalStiffnessMeasure (IfcAbstractEntity* e); IfcRotationalStiffnessMeasure (double v); @@ -5975,10 +5729,7 @@ public: class IfcSecondInMinute : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcSecondInMinute (IfcAbstractEntity* e); IfcSecondInMinute (double v); @@ -5991,10 +5742,7 @@ public: /// HISTORY New type in IFC Release 2x2. class IfcSectionModulusMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcSectionModulusMeasure (IfcAbstractEntity* e); IfcSectionModulusMeasure (double v); @@ -6007,10 +5755,7 @@ public: /// HISTORY New type in IFC2x2. class IfcSectionalAreaIntegralMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcSectionalAreaIntegralMeasure (IfcAbstractEntity* e); IfcSectionalAreaIntegralMeasure (double v); @@ -6023,10 +5768,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcShearModulusMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcShearModulusMeasure (IfcAbstractEntity* e); IfcShearModulusMeasure (double v); @@ -6041,10 +5783,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcSolidAngleMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcSolidAngleMeasure (IfcAbstractEntity* e); IfcSolidAngleMeasure (double v); @@ -6057,10 +5796,7 @@ public: /// HISTORY New type in IFC2x2. class IfcSoundPowerMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcSoundPowerMeasure (IfcAbstractEntity* e); IfcSoundPowerMeasure (double v); @@ -6073,10 +5809,7 @@ public: /// HISTORY New type in IFC2x2. class IfcSoundPressureMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcSoundPressureMeasure (IfcAbstractEntity* e); IfcSoundPressureMeasure (double v); @@ -6089,10 +5822,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcSpecificHeatCapacityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcSpecificHeatCapacityMeasure (IfcAbstractEntity* e); IfcSpecificHeatCapacityMeasure (double v); @@ -6107,10 +5837,7 @@ public: /// HISTORY: New type in IFC2x2. class IfcSpecularExponent : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcSpecularExponent (IfcAbstractEntity* e); IfcSpecularExponent (double v); @@ -6127,10 +5854,7 @@ public: /// HISTORY: New type in Release IFC2x2. class IfcSpecularRoughness : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcSpecularRoughness (IfcAbstractEntity* e); IfcSpecularRoughness (double v); @@ -6143,10 +5867,7 @@ public: /// HISTORY New type in IFC2x2. class IfcTemperatureGradientMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcTemperatureGradientMeasure (IfcAbstractEntity* e); IfcTemperatureGradientMeasure (double v); @@ -6165,10 +5886,7 @@ public: /// Note that while IfcText is not formally restricted in length, the size of a string in ISO 10303-21:2002 conforming exchange files must not exceed 32767 octets after encoding and escaping. class IfcText : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcText (IfcAbstractEntity* e); IfcText (std::string v); @@ -6186,10 +5904,7 @@ public: /// HISTORY  New type in IFC2x3. class IfcTextAlignment : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcTextAlignment (IfcAbstractEntity* e); IfcTextAlignment (std::string v); @@ -6210,10 +5925,7 @@ public: /// HISTORY  New type in IFC2x3. class IfcTextDecoration : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcTextDecoration (IfcAbstractEntity* e); IfcTextDecoration (std::string v); @@ -6240,10 +5952,7 @@ public: /// IFC2x2 Addendum 2 CHANGE: The IfcFontFamily has been added. class IfcTextFontName : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcTextFontName (IfcAbstractEntity* e); IfcTextFontName (std::string v); @@ -6261,10 +5970,7 @@ public: /// HISTORY  New type in IFC2x3. class IfcTextTransformation : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcTextTransformation (IfcAbstractEntity* e); IfcTextTransformation (std::string v); @@ -6277,10 +5983,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcThermalAdmittanceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcThermalAdmittanceMeasure (IfcAbstractEntity* e); IfcThermalAdmittanceMeasure (double v); @@ -6293,10 +5996,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcThermalConductivityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcThermalConductivityMeasure (IfcAbstractEntity* e); IfcThermalConductivityMeasure (double v); @@ -6308,10 +6008,7 @@ public: /// HISTORY New type in IFC2x2. class IfcThermalExpansionCoefficientMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcThermalExpansionCoefficientMeasure (IfcAbstractEntity* e); IfcThermalExpansionCoefficientMeasure (double v); @@ -6323,10 +6020,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcThermalResistanceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcThermalResistanceMeasure (IfcAbstractEntity* e); IfcThermalResistanceMeasure (double v); @@ -6339,10 +6033,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcThermalTransmittanceMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcThermalTransmittanceMeasure (IfcAbstractEntity* e); IfcThermalTransmittanceMeasure (double v); @@ -6357,10 +6048,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcThermodynamicTemperatureMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcThermodynamicTemperatureMeasure (IfcAbstractEntity* e); IfcThermodynamicTemperatureMeasure (double v); @@ -6375,10 +6063,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcTimeMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcTimeMeasure (IfcAbstractEntity* e); IfcTimeMeasure (double v); @@ -6390,10 +6075,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcTimeStamp : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcTimeStamp (IfcAbstractEntity* e); IfcTimeStamp (int v); @@ -6406,10 +6088,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcTorqueMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcTorqueMeasure (IfcAbstractEntity* e); IfcTorqueMeasure (double v); @@ -6422,10 +6101,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcVaporPermeabilityMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcVaporPermeabilityMeasure (IfcAbstractEntity* e); IfcVaporPermeabilityMeasure (double v); @@ -6440,10 +6116,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcVolumeMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcVolumeMeasure (IfcAbstractEntity* e); IfcVolumeMeasure (double v); @@ -6456,10 +6129,7 @@ public: /// HISTORY New type in IFC Release 2.0. class IfcVolumetricFlowRateMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcVolumetricFlowRateMeasure (IfcAbstractEntity* e); IfcVolumetricFlowRateMeasure (double v); @@ -6472,10 +6142,7 @@ public: /// HISTORY New type in IFC2x2. class IfcWarpingConstantMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcWarpingConstantMeasure (IfcAbstractEntity* e); IfcWarpingConstantMeasure (double v); @@ -6488,10 +6155,7 @@ public: /// HISTORY New type in IFC2x2. class IfcWarpingMomentMeasure : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcWarpingMomentMeasure (IfcAbstractEntity* e); IfcWarpingMomentMeasure (double v); @@ -6500,10 +6164,7 @@ public: class IfcYearNumber : public IfcUtil::IfcBaseType { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcYearNumber (IfcAbstractEntity* e); IfcYearNumber (int v); @@ -6536,10 +6197,7 @@ public: /// IFC2x3 CHANGE  The IfcBoxAlignment has been added. class IfcBoxAlignment : public IfcLabel { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcBoxAlignment (IfcAbstractEntity* e); IfcBoxAlignment (std::string v); @@ -6552,10 +6210,7 @@ public: /// HISTORY New type in IFC Release 2x. class IfcNormalisedRatioMeasure : public IfcRatioMeasure { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcNormalisedRatioMeasure (IfcAbstractEntity* e); IfcNormalisedRatioMeasure (double v); @@ -6569,10 +6224,7 @@ public: /// HISTORY New type in IFC Release 1.5.1. class IfcPositiveRatioMeasure : public IfcRatioMeasure { public: - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const; - virtual Argument* getArgument(unsigned int i) const; - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::type_declaration& declaration() const; static Type::Enum Class(); explicit IfcPositiveRatioMeasure (IfcAbstractEntity* e); IfcPositiveRatioMeasure (double v); @@ -6609,13 +6261,7 @@ public: /// A textual description relating the nature of the role played by an actor. std::string Description() const; void setDescription(std::string v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRoleEnum; case 1: return Type::IfcLabel; case 2: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Role"; case 1: return "UserDefinedRole"; case 2: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcActorRole (IfcAbstractEntity* e); IfcActorRole (IfcRoleEnum::IfcRoleEnum v1_Role, boost::optional< std::string > v2_UserDefinedRole, boost::optional< std::string > v3_Description); @@ -6646,15 +6292,9 @@ public: /// attribute Purpose shall have enumeration value USERDEFINED. std::string UserDefinedPurpose() const; void setUserDefinedPurpose(std::string v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAddressTypeEnum; case 1: return Type::IfcText; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Purpose"; case 1: return "Description"; case 2: return "UserDefinedPurpose"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcPerson >::ptr OfPerson() const; // INVERSE IfcPerson::Addresses + IfcTemplatedEntityList< IfcPerson >::ptr OfPerson() const; // INVERSE IfcPerson::Addresses IfcTemplatedEntityList< IfcOrganization >::ptr OfOrganization() const; // INVERSE IfcOrganization::Addresses - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAddress (IfcAbstractEntity* e); IfcAddress (boost::optional< IfcAddressTypeEnum::IfcAddressTypeEnum > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose); @@ -6677,13 +6317,7 @@ public: /// Short identifying name for the application. std::string ApplicationIdentifier() const; void setApplicationIdentifier(std::string v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcOrganization; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ApplicationDeveloper"; case 1: return "Version"; case 2: return "ApplicationFullName"; case 3: return "ApplicationIdentifier"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcApplication (IfcAbstractEntity* e); IfcApplication (IfcOrganization* v1_ApplicationDeveloper, std::string v2_Version, std::string v3_ApplicationFullName, std::string v4_ApplicationIdentifier); @@ -6743,16 +6377,10 @@ public: /// IFC2x4 CHANGE Type changed from IfcDateTimeSelect. IfcDateTimeSelect* FixedUntilDate() const; void setFixedUntilDate(IfcDateTimeSelect* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcAppliedValueSelect; case 3: return Type::IfcMeasureWithUnit; case 4: return Type::IfcDateTimeSelect; case 5: return Type::IfcDateTimeSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "AppliedValue"; case 3: return "UnitBasis"; case 4: return "ApplicableDate"; case 5: return "FixedUntilDate"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcReferencesValueDocument >::ptr ValuesReferenced() const; // INVERSE IfcReferencesValueDocument::ReferencingValues + IfcTemplatedEntityList< IfcReferencesValueDocument >::ptr ValuesReferenced() const; // INVERSE IfcReferencesValueDocument::ReferencingValues IfcTemplatedEntityList< IfcAppliedValueRelationship >::ptr ValueOfComponents() const; // INVERSE IfcAppliedValueRelationship::ComponentOfTotal IfcTemplatedEntityList< IfcAppliedValueRelationship >::ptr IsComponentIn() const; // INVERSE IfcAppliedValueRelationship::Components - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAppliedValue (IfcAbstractEntity* e); IfcAppliedValue (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcAppliedValueSelect* v3_AppliedValue, IfcMeasureWithUnit* v4_UnitBasis, IfcDateTimeSelect* v5_ApplicableDate, IfcDateTimeSelect* v6_FixedUntilDate); @@ -6801,13 +6429,7 @@ public: bool hasDescription() const; std::string Description() const; void setDescription(std::string v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAppliedValue; case 1: return Type::IfcAppliedValue; case 2: return Type::IfcArithmeticOperatorEnum; case 3: return Type::IfcLabel; case 4: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ComponentOfTotal"; case 1: return "Components"; case 2: return "ArithmeticOperator"; case 3: return "Name"; case 4: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAppliedValueRelationship (IfcAbstractEntity* e); IfcAppliedValueRelationship (IfcAppliedValue* v1_ComponentOfTotal, IfcTemplatedEntityList< IfcAppliedValue >::ptr v2_Components, IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum v3_ArithmeticOperator, boost::optional< std::string > v4_Name, boost::optional< std::string > v5_Description); @@ -6845,16 +6467,10 @@ public: /// A computer interpretable identifier by which the approval is known. std::string Identifier() const; void setIdentifier(std::string v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcText; case 1: return Type::IfcDateTimeSelect; case 2: return Type::IfcLabel; case 3: return Type::IfcLabel; case 4: return Type::IfcText; case 5: return Type::IfcLabel; case 6: return Type::IfcIdentifier; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Description"; case 1: return "ApprovalDateTime"; case 2: return "ApprovalStatus"; case 3: return "ApprovalLevel"; case 4: return "ApprovalQualifier"; case 5: return "Name"; case 6: return "Identifier"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcApprovalActorRelationship >::ptr Actors() const; // INVERSE IfcApprovalActorRelationship::Approval + IfcTemplatedEntityList< IfcApprovalActorRelationship >::ptr Actors() const; // INVERSE IfcApprovalActorRelationship::Approval IfcTemplatedEntityList< IfcApprovalRelationship >::ptr IsRelatedWith() const; // INVERSE IfcApprovalRelationship::RelatedApproval IfcTemplatedEntityList< IfcApprovalRelationship >::ptr Relates() const; // INVERSE IfcApprovalRelationship::RelatingApproval - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcApproval (IfcAbstractEntity* e); IfcApproval (boost::optional< std::string > v1_Description, IfcDateTimeSelect* v2_ApprovalDateTime, boost::optional< std::string > v3_ApprovalStatus, boost::optional< std::string > v4_ApprovalLevel, boost::optional< std::string > v5_ApprovalQualifier, std::string v6_Name, std::string v7_Identifier); @@ -6869,13 +6485,7 @@ public: void setApproval(IfcApproval* v); IfcActorRole* Role() const; void setRole(IfcActorRole* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcActorSelect; case 1: return Type::IfcApproval; case 2: return Type::IfcActorRole; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Actor"; case 1: return "Approval"; case 2: return "Role"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcApprovalActorRelationship (IfcAbstractEntity* e); IfcApprovalActorRelationship (IfcActorSelect* v1_Actor, IfcApproval* v2_Approval, IfcActorRole* v3_Role); @@ -6888,13 +6498,7 @@ public: void setApprovedProperties(IfcTemplatedEntityList< IfcProperty >::ptr v); IfcApproval* Approval() const; void setApproval(IfcApproval* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcProperty; case 1: return Type::IfcApproval; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ApprovedProperties"; case 1: return "Approval"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcApprovalPropertyRelationship (IfcAbstractEntity* e); IfcApprovalPropertyRelationship (IfcTemplatedEntityList< IfcProperty >::ptr v1_ApprovedProperties, IfcApproval* v2_Approval); @@ -6920,13 +6524,7 @@ public: void setDescription(std::string v); std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcApproval; case 1: return Type::IfcApproval; case 2: return Type::IfcText; case 3: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelatedApproval"; case 1: return "RelatingApproval"; case 2: return "Description"; case 3: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcApprovalRelationship (IfcAbstractEntity* e); IfcApprovalRelationship (IfcApproval* v1_RelatedApproval, IfcApproval* v2_RelatingApproval, boost::optional< std::string > v3_Description, std::string v4_Name); @@ -6954,13 +6552,7 @@ public: /// Optionally defines a name for this boundary condition. std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoundaryCondition (IfcAbstractEntity* e); IfcBoundaryCondition (boost::optional< std::string > v1_Name); @@ -7005,13 +6597,7 @@ public: /// Rotational stiffness value about the z-axis of the coordinate system defined by the instance which uses this resource object. double RotationalStiffnessByLengthZ() const; void setRotationalStiffnessByLengthZ(double v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; } return IfcBoundaryCondition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcModulusOfLinearSubgradeReactionMeasure; case 2: return Type::IfcModulusOfLinearSubgradeReactionMeasure; case 3: return Type::IfcModulusOfLinearSubgradeReactionMeasure; case 4: return Type::IfcModulusOfRotationalSubgradeReactionMeasure; case 5: return Type::IfcModulusOfRotationalSubgradeReactionMeasure; case 6: return Type::IfcModulusOfRotationalSubgradeReactionMeasure; } return IfcBoundaryCondition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "LinearStiffnessByLengthX"; case 2: return "LinearStiffnessByLengthY"; case 3: return "LinearStiffnessByLengthZ"; case 4: return "RotationalStiffnessByLengthX"; case 5: return "RotationalStiffnessByLengthY"; case 6: return "RotationalStiffnessByLengthZ"; } return IfcBoundaryCondition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoundaryEdgeCondition (IfcAbstractEntity* e); IfcBoundaryEdgeCondition (boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessByLengthX, boost::optional< double > v3_LinearStiffnessByLengthY, boost::optional< double > v4_LinearStiffnessByLengthZ, boost::optional< double > v5_RotationalStiffnessByLengthX, boost::optional< double > v6_RotationalStiffnessByLengthY, boost::optional< double > v7_RotationalStiffnessByLengthZ); @@ -7041,13 +6627,7 @@ public: bool hasLinearStiffnessByAreaZ() const; double LinearStiffnessByAreaZ() const; void setLinearStiffnessByAreaZ(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcBoundaryCondition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcModulusOfSubgradeReactionMeasure; case 2: return Type::IfcModulusOfSubgradeReactionMeasure; case 3: return Type::IfcModulusOfSubgradeReactionMeasure; } return IfcBoundaryCondition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "LinearStiffnessByAreaX"; case 2: return "LinearStiffnessByAreaY"; case 3: return "LinearStiffnessByAreaZ"; } return IfcBoundaryCondition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoundaryFaceCondition (IfcAbstractEntity* e); IfcBoundaryFaceCondition (boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessByAreaX, boost::optional< double > v3_LinearStiffnessByAreaY, boost::optional< double > v4_LinearStiffnessByAreaZ); @@ -7092,13 +6672,7 @@ public: /// Rotational stiffness value about the z-axis of the coordinate system defined by the instance which uses this resource object. double RotationalStiffnessZ() const; void setRotationalStiffnessZ(double v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; } return IfcBoundaryCondition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcLinearStiffnessMeasure; case 2: return Type::IfcLinearStiffnessMeasure; case 3: return Type::IfcLinearStiffnessMeasure; case 4: return Type::IfcRotationalStiffnessMeasure; case 5: return Type::IfcRotationalStiffnessMeasure; case 6: return Type::IfcRotationalStiffnessMeasure; } return IfcBoundaryCondition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "LinearStiffnessX"; case 2: return "LinearStiffnessY"; case 3: return "LinearStiffnessZ"; case 4: return "RotationalStiffnessX"; case 5: return "RotationalStiffnessY"; case 6: return "RotationalStiffnessZ"; } return IfcBoundaryCondition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoundaryNodeCondition (IfcAbstractEntity* e); IfcBoundaryNodeCondition (boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessX, boost::optional< double > v3_LinearStiffnessY, boost::optional< double > v4_LinearStiffnessZ, boost::optional< double > v5_RotationalStiffnessX, boost::optional< double > v6_RotationalStiffnessY, boost::optional< double > v7_RotationalStiffnessZ); @@ -7120,13 +6694,7 @@ public: /// Defines the warping stiffness value. double WarpingStiffness() const; void setWarpingStiffness(double v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_DOUBLE; } return IfcBoundaryNodeCondition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcWarpingMomentMeasure; } return IfcBoundaryNodeCondition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "WarpingStiffness"; } return IfcBoundaryNodeCondition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoundaryNodeConditionWarping (IfcAbstractEntity* e); IfcBoundaryNodeConditionWarping (boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessX, boost::optional< double > v3_LinearStiffnessY, boost::optional< double > v4_LinearStiffnessZ, boost::optional< double > v5_RotationalStiffnessX, boost::optional< double > v6_RotationalStiffnessY, boost::optional< double > v7_RotationalStiffnessZ, boost::optional< double > v8_WarpingStiffness); @@ -7141,13 +6709,7 @@ public: void setMonthComponent(int v); int YearComponent() const; void setYearComponent(int v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_INT; case 1: return IfcUtil::Argument_INT; case 2: return IfcUtil::Argument_INT; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDayInMonthNumber; case 1: return Type::IfcMonthInYearNumber; case 2: return Type::IfcYearNumber; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DayComponent"; case 1: return "MonthComponent"; case 2: return "YearComponent"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCalendarDate (IfcAbstractEntity* e); IfcCalendarDate (int v1_DayComponent, int v2_MonthComponent, int v3_YearComponent); @@ -7196,14 +6758,8 @@ public: /// NOTE Examples of names include CI/SfB, Masterformat, BSAB, Uniclass, STABU, DIN276, DIN277 etc. std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcLabel; case 2: return Type::IfcCalendarDate; case 3: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Source"; case 1: return "Edition"; case 2: return "EditionDate"; case 3: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcClassificationItem >::ptr Contains() const; // INVERSE IfcClassificationItem::ItemOf - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcClassificationItem >::ptr Contains() const; // INVERSE IfcClassificationItem::ItemOf + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcClassification (IfcAbstractEntity* e); IfcClassification (std::string v1_Source, std::string v2_Edition, IfcCalendarDate* v3_EditionDate, std::string v4_Name); @@ -7220,15 +6776,9 @@ public: void setItemOf(IfcClassification* v); std::string Title() const; void setTitle(std::string v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcClassificationNotationFacet; case 1: return Type::IfcClassification; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Notation"; case 1: return "ItemOf"; case 2: return "Title"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcClassificationItemRelationship >::ptr IsClassifiedItemIn() const; // INVERSE IfcClassificationItemRelationship::RelatedItems + IfcTemplatedEntityList< IfcClassificationItemRelationship >::ptr IsClassifiedItemIn() const; // INVERSE IfcClassificationItemRelationship::RelatedItems IfcTemplatedEntityList< IfcClassificationItemRelationship >::ptr IsClassifyingItemIn() const; // INVERSE IfcClassificationItemRelationship::RelatingItem - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcClassificationItem (IfcAbstractEntity* e); IfcClassificationItem (IfcClassificationNotationFacet* v1_Notation, IfcClassification* v2_ItemOf, std::string v3_Title); @@ -7241,13 +6791,7 @@ public: void setRelatingItem(IfcClassificationItem* v); IfcTemplatedEntityList< IfcClassificationItem >::ptr RelatedItems() const; void setRelatedItems(IfcTemplatedEntityList< IfcClassificationItem >::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcClassificationItem; case 1: return Type::IfcClassificationItem; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelatingItem"; case 1: return "RelatedItems"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcClassificationItemRelationship (IfcAbstractEntity* e); IfcClassificationItemRelationship (IfcClassificationItem* v1_RelatingItem, IfcTemplatedEntityList< IfcClassificationItem >::ptr v2_RelatedItems); @@ -7258,13 +6802,7 @@ class IfcClassificationNotation : public IfcUtil::IfcBaseEntity { public: IfcTemplatedEntityList< IfcClassificationNotationFacet >::ptr NotationFacets() const; void setNotationFacets(IfcTemplatedEntityList< IfcClassificationNotationFacet >::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcClassificationNotationFacet; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "NotationFacets"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcClassificationNotation (IfcAbstractEntity* e); IfcClassificationNotation (IfcTemplatedEntityList< IfcClassificationNotationFacet >::ptr v1_NotationFacets); @@ -7275,13 +6813,7 @@ class IfcClassificationNotationFacet : public IfcUtil::IfcBaseEntity { public: std::string NotationValue() const; void setNotationValue(std::string v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "NotationValue"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcClassificationNotationFacet (IfcAbstractEntity* e); IfcClassificationNotationFacet (std::string v1_NotationValue); @@ -7302,13 +6834,7 @@ public: /// IFC2x Edition 3 CHANGE  Attribute added. std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcColourSpecification (IfcAbstractEntity* e); IfcColourSpecification (boost::optional< std::string > v1_Name); @@ -7330,13 +6856,7 @@ public: /// IFC2x Edition 3 CHANGE  The definition of the subtypes has been enhanced by allowing either geometric representation items (point | curve | surface) or topological representation items with associated geometry (vertex point | edge curve | face  surface). class IfcConnectionGeometry : public IfcUtil::IfcBaseEntity { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConnectionGeometry (IfcAbstractEntity* e); IfcConnectionGeometry (); @@ -7368,13 +6888,7 @@ public: /// Point at which connected objects are aligned at the related element, given in the LCS of the related element. If the information is omitted, then the origin of the related element is used. IfcPointOrVertexPoint* PointOnRelatedElement() const; void setPointOnRelatedElement(IfcPointOrVertexPoint* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcConnectionGeometry::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPointOrVertexPoint; case 1: return Type::IfcPointOrVertexPoint; } return IfcConnectionGeometry::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "PointOnRelatingElement"; case 1: return "PointOnRelatedElement"; } return IfcConnectionGeometry::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConnectionPointGeometry (IfcAbstractEntity* e); IfcConnectionPointGeometry (IfcPointOrVertexPoint* v1_PointOnRelatingElement, IfcPointOrVertexPoint* v2_PointOnRelatedElement); @@ -7391,13 +6905,7 @@ public: void setLocationAtRelatedElement(IfcAxis2Placement* v); IfcProfileDef* ProfileOfPort() const; void setProfileOfPort(IfcProfileDef* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcConnectionGeometry::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAxis2Placement; case 1: return Type::IfcAxis2Placement; case 2: return Type::IfcProfileDef; } return IfcConnectionGeometry::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LocationAtRelatingElement"; case 1: return "LocationAtRelatedElement"; case 2: return "ProfileOfPort"; } return IfcConnectionGeometry::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConnectionPortGeometry (IfcAbstractEntity* e); IfcConnectionPortGeometry (IfcAxis2Placement* v1_LocationAtRelatingElement, IfcAxis2Placement* v2_LocationAtRelatedElement, IfcProfileDef* v3_ProfileOfPort); @@ -7421,13 +6929,7 @@ public: /// Surface at which the relating element is aligned at the related element, given in the LCS of the related element. If the information is omitted, then the origin of the related element is used. IfcSurfaceOrFaceSurface* SurfaceOnRelatedElement() const; void setSurfaceOnRelatedElement(IfcSurfaceOrFaceSurface* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcConnectionGeometry::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcSurfaceOrFaceSurface; case 1: return Type::IfcSurfaceOrFaceSurface; } return IfcConnectionGeometry::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SurfaceOnRelatingElement"; case 1: return "SurfaceOnRelatedElement"; } return IfcConnectionGeometry::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConnectionSurfaceGeometry (IfcAbstractEntity* e); IfcConnectionSurfaceGeometry (IfcSurfaceOrFaceSurface* v1_SurfaceOnRelatingElement, IfcSurfaceOrFaceSurface* v2_SurfaceOnRelatedElement); @@ -7481,19 +6983,13 @@ public: /// When a value is provided for attribute UserDefinedGrade in parallel the attribute ConstraintGrade shall have enumeration value USERDEFINED. std::string UserDefinedGrade() const; void setUserDefinedGrade(std::string v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcConstraintEnum; case 3: return Type::IfcLabel; case 4: return Type::IfcActorSelect; case 5: return Type::IfcDateTimeSelect; case 6: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "ConstraintGrade"; case 3: return "ConstraintSource"; case 4: return "CreatingActor"; case 5: return "CreationTime"; case 6: return "UserDefinedGrade"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcConstraintClassificationRelationship >::ptr ClassifiedAs() const; // INVERSE IfcConstraintClassificationRelationship::ClassifiedConstraint + IfcTemplatedEntityList< IfcConstraintClassificationRelationship >::ptr ClassifiedAs() const; // INVERSE IfcConstraintClassificationRelationship::ClassifiedConstraint IfcTemplatedEntityList< IfcConstraintRelationship >::ptr RelatesConstraints() const; // INVERSE IfcConstraintRelationship::RelatingConstraint IfcTemplatedEntityList< IfcConstraintRelationship >::ptr IsRelatedWith() const; // INVERSE IfcConstraintRelationship::RelatedConstraints IfcTemplatedEntityList< IfcPropertyConstraintRelationship >::ptr PropertiesForConstraint() const; // INVERSE IfcPropertyConstraintRelationship::RelatingConstraint IfcTemplatedEntityList< IfcConstraintAggregationRelationship >::ptr Aggregates() const; // INVERSE IfcConstraintAggregationRelationship::RelatingConstraint IfcTemplatedEntityList< IfcConstraintAggregationRelationship >::ptr IsAggregatedIn() const; // INVERSE IfcConstraintAggregationRelationship::RelatedConstraints - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstraint (IfcAbstractEntity* e); IfcConstraint (std::string v1_Name, boost::optional< std::string > v2_Description, IfcConstraintEnum::IfcConstraintEnum v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, IfcActorSelect* v5_CreatingActor, IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade); @@ -7527,13 +7023,7 @@ public: /// Enumeration that identifies the logical type of aggregation. IfcLogicalOperatorEnum::IfcLogicalOperatorEnum LogicalAggregator() const; void setLogicalAggregator(IfcLogicalOperatorEnum::IfcLogicalOperatorEnum v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENUMERATION; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcConstraint; case 3: return Type::IfcConstraint; case 4: return Type::IfcLogicalOperatorEnum; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "RelatingConstraint"; case 3: return "RelatedConstraints"; case 4: return "LogicalAggregator"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstraintAggregationRelationship (IfcAbstractEntity* e); IfcConstraintAggregationRelationship (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcConstraint* v3_RelatingConstraint, IfcTemplatedEntityList< IfcConstraint >::ptr v4_RelatedConstraints, IfcLogicalOperatorEnum::IfcLogicalOperatorEnum v5_LogicalAggregator); @@ -7546,13 +7036,7 @@ public: void setClassifiedConstraint(IfcConstraint* v); IfcEntityList::ptr RelatedClassifications() const; void setRelatedClassifications(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcConstraint; case 1: return Type::IfcClassificationNotationSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ClassifiedConstraint"; case 1: return "RelatedClassifications"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstraintClassificationRelationship (IfcAbstractEntity* e); IfcConstraintClassificationRelationship (IfcConstraint* v1_ClassifiedConstraint, IfcEntityList::ptr v2_RelatedClassifications); @@ -7583,13 +7067,7 @@ public: /// Constraints that are related with the one referenced as RelatingConstraint. IfcTemplatedEntityList< IfcConstraint >::ptr RelatedConstraints() const; void setRelatedConstraints(IfcTemplatedEntityList< IfcConstraint >::ptr v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcConstraint; case 3: return Type::IfcConstraint; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "RelatingConstraint"; case 3: return "RelatedConstraints"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstraintRelationship (IfcAbstractEntity* e); IfcConstraintRelationship (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcConstraint* v3_RelatingConstraint, IfcTemplatedEntityList< IfcConstraint >::ptr v4_RelatedConstraints); @@ -7606,13 +7084,7 @@ public: void setMinuteOffset(int v); IfcAheadOrBehind::IfcAheadOrBehind Sense() const; void setSense(IfcAheadOrBehind::IfcAheadOrBehind v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_INT; case 1: return IfcUtil::Argument_INT; case 2: return IfcUtil::Argument_ENUMERATION; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcHourInDay; case 1: return Type::IfcMinuteInHour; case 2: return Type::IfcAheadOrBehind; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "HourOffset"; case 1: return "MinuteOffset"; case 2: return "Sense"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCoordinatedUniversalTimeOffset (IfcAbstractEntity* e); IfcCoordinatedUniversalTimeOffset (int v1_HourOffset, boost::optional< int > v2_MinuteOffset, IfcAheadOrBehind::IfcAheadOrBehind v3_Sense); @@ -7674,13 +7146,7 @@ public: /// The condition under which a cost value applies. std::string Condition() const; void setCondition(std::string v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_STRING; } return IfcAppliedValue::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcLabel; case 7: return Type::IfcText; } return IfcAppliedValue::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "CostType"; case 7: return "Condition"; } return IfcAppliedValue::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCostValue (IfcAbstractEntity* e); IfcCostValue (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcAppliedValueSelect* v3_AppliedValue, IfcMeasureWithUnit* v4_UnitBasis, IfcDateTimeSelect* v5_ApplicableDate, IfcDateTimeSelect* v6_FixedUntilDate, std::string v7_CostType, boost::optional< std::string > v8_Condition); @@ -7718,13 +7184,7 @@ public: /// The source from which an exchange rate is obtained. IfcLibraryInformation* RateSource() const; void setRateSource(IfcLibraryInformation* v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMonetaryUnit; case 1: return Type::IfcMonetaryUnit; case 2: return Type::IfcPositiveRatioMeasure; case 3: return Type::IfcDateAndTime; case 4: return Type::IfcLibraryInformation; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelatingMonetaryUnit"; case 1: return "RelatedMonetaryUnit"; case 2: return "ExchangeRate"; case 3: return "RateDateTime"; case 4: return "RateSource"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCurrencyRelationship (IfcAbstractEntity* e); IfcCurrencyRelationship (IfcMonetaryUnit* v1_RelatingMonetaryUnit, IfcMonetaryUnit* v2_RelatedMonetaryUnit, double v3_ExchangeRate, IfcDateAndTime* v4_RateDateTime, IfcLibraryInformation* v5_RateSource); @@ -7745,13 +7205,7 @@ public: /// A list of curve font pattern entities, that contains the simple patterns used for drawing curves. The patterns are applied in the order they occur in the list. IfcTemplatedEntityList< IfcCurveStyleFontPattern >::ptr PatternList() const; void setPatternList(IfcTemplatedEntityList< IfcCurveStyleFontPattern >::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcCurveStyleFontPattern; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "PatternList"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCurveStyleFont (IfcAbstractEntity* e); IfcCurveStyleFont (boost::optional< std::string > v1_Name, IfcTemplatedEntityList< IfcCurveStyleFontPattern >::ptr v2_PatternList); @@ -7781,13 +7235,7 @@ public: /// The scale factor. double CurveFontScaling() const; void setCurveFontScaling(double v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcCurveStyleFontSelect; case 2: return Type::IfcPositiveRatioMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "CurveFont"; case 2: return "CurveFontScaling"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCurveStyleFontAndScaling (IfcAbstractEntity* e); IfcCurveStyleFontAndScaling (boost::optional< std::string > v1_Name, IfcCurveStyleFontSelect* v2_CurveFont, double v3_CurveFontScaling); @@ -7810,13 +7258,7 @@ public: /// The length of the invisible segment in the pattern definition. double InvisibleSegmentLength() const; void setInvisibleSegmentLength(double v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLengthMeasure; case 1: return Type::IfcPositiveLengthMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "VisibleSegmentLength"; case 1: return "InvisibleSegmentLength"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCurveStyleFontPattern (IfcAbstractEntity* e); IfcCurveStyleFontPattern (double v1_VisibleSegmentLength, double v2_InvisibleSegmentLength); @@ -7829,13 +7271,7 @@ public: void setDateComponent(IfcCalendarDate* v); IfcLocalTime* TimeComponent() const; void setTimeComponent(IfcLocalTime* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCalendarDate; case 1: return Type::IfcLocalTime; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DateComponent"; case 1: return "TimeComponent"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDateAndTime (IfcAbstractEntity* e); IfcDateAndTime (IfcCalendarDate* v1_DateComponent, IfcLocalTime* v2_TimeComponent); @@ -7860,13 +7296,7 @@ public: bool hasUserDefinedType() const; std::string UserDefinedType() const; void setUserDefinedType(std::string v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDerivedUnitElement; case 1: return Type::IfcDerivedUnitEnum; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Elements"; case 1: return "UnitType"; case 2: return "UserDefinedType"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDerivedUnit (IfcAbstractEntity* e); IfcDerivedUnit (IfcTemplatedEntityList< IfcDerivedUnitElement >::ptr v1_Elements, IfcDerivedUnitEnum::IfcDerivedUnitEnum v2_UnitType, boost::optional< std::string > v3_UserDefinedType); @@ -7889,13 +7319,7 @@ public: /// The power that is applied to the unit attribute. int Exponent() const; void setExponent(int v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_INT; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcNamedUnit; case 1: return Type::UNDEFINED; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Unit"; case 1: return "Exponent"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDerivedUnitElement (IfcAbstractEntity* e); IfcDerivedUnitElement (IfcNamedUnit* v1_Unit, int v2_Exponent); @@ -7941,13 +7365,7 @@ public: /// The power of the luminous intensity base quantity. int LuminousIntensityExponent() const; void setLuminousIntensityExponent(int v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_INT; case 1: return IfcUtil::Argument_INT; case 2: return IfcUtil::Argument_INT; case 3: return IfcUtil::Argument_INT; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::UNDEFINED; case 1: return Type::UNDEFINED; case 2: return Type::UNDEFINED; case 3: return Type::UNDEFINED; case 4: return Type::UNDEFINED; case 5: return Type::UNDEFINED; case 6: return Type::UNDEFINED; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LengthExponent"; case 1: return "MassExponent"; case 2: return "TimeExponent"; case 3: return "ElectricCurrentExponent"; case 4: return "ThermodynamicTemperatureExponent"; case 5: return "AmountOfSubstanceExponent"; case 6: return "LuminousIntensityExponent"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDimensionalExponents (IfcAbstractEntity* e); IfcDimensionalExponents (int v1_LengthExponent, int v2_MassExponent, int v3_TimeExponent, int v4_ElectricCurrentExponent, int v5_ThermodynamicTemperatureExponent, int v6_AmountOfSubstanceExponent, int v7_LuminousIntensityExponent); @@ -7973,13 +7391,7 @@ public: /// Mime subtype information. std::string MimeSubtype() const; void setMimeSubtype(std::string v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "FileExtension"; case 1: return "MimeContentType"; case 2: return "MimeSubtype"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDocumentElectronicFormat (IfcAbstractEntity* e); IfcDocumentElectronicFormat (boost::optional< std::string > v1_FileExtension, boost::optional< std::string > v2_MimeContentType, boost::optional< std::string > v3_MimeSubtype); @@ -8082,15 +7494,9 @@ public: /// - REVISION IfcDocumentStatusEnum::IfcDocumentStatusEnum Status() const; void setStatus(IfcDocumentStatusEnum::IfcDocumentStatusEnum v); - virtual unsigned int getArgumentCount() const { return 17; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_ENTITY_INSTANCE; case 11: return IfcUtil::Argument_ENTITY_INSTANCE; case 12: return IfcUtil::Argument_ENTITY_INSTANCE; case 13: return IfcUtil::Argument_ENTITY_INSTANCE; case 14: return IfcUtil::Argument_ENTITY_INSTANCE; case 15: return IfcUtil::Argument_ENUMERATION; case 16: return IfcUtil::Argument_ENUMERATION; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcDocumentReference; case 4: return Type::IfcText; case 5: return Type::IfcText; case 6: return Type::IfcText; case 7: return Type::IfcLabel; case 8: return Type::IfcActorSelect; case 9: return Type::IfcActorSelect; case 10: return Type::IfcDateAndTime; case 11: return Type::IfcDateAndTime; case 12: return Type::IfcDocumentElectronicFormat; case 13: return Type::IfcCalendarDate; case 14: return Type::IfcCalendarDate; case 15: return Type::IfcDocumentConfidentialityEnum; case 16: return Type::IfcDocumentStatusEnum; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DocumentId"; case 1: return "Name"; case 2: return "Description"; case 3: return "DocumentReferences"; case 4: return "Purpose"; case 5: return "IntendedUse"; case 6: return "Scope"; case 7: return "Revision"; case 8: return "DocumentOwner"; case 9: return "Editors"; case 10: return "CreationTime"; case 11: return "LastRevisionTime"; case 12: return "ElectronicFormat"; case 13: return "ValidFrom"; case 14: return "ValidUntil"; case 15: return "Confidentiality"; case 16: return "Status"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcDocumentInformationRelationship >::ptr IsPointedTo() const; // INVERSE IfcDocumentInformationRelationship::RelatedDocuments + IfcTemplatedEntityList< IfcDocumentInformationRelationship >::ptr IsPointedTo() const; // INVERSE IfcDocumentInformationRelationship::RelatedDocuments IfcTemplatedEntityList< IfcDocumentInformationRelationship >::ptr IsPointer() const; // INVERSE IfcDocumentInformationRelationship::RelatingDocument - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDocumentInformation (IfcAbstractEntity* e); IfcDocumentInformation (std::string v1_DocumentId, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< IfcTemplatedEntityList< IfcDocumentReference >::ptr > v4_DocumentReferences, boost::optional< std::string > v5_Purpose, boost::optional< std::string > v6_IntendedUse, boost::optional< std::string > v7_Scope, boost::optional< std::string > v8_Revision, IfcActorSelect* v9_DocumentOwner, boost::optional< IfcEntityList::ptr > v10_Editors, IfcDateAndTime* v11_CreationTime, IfcDateAndTime* v12_LastRevisionTime, IfcDocumentElectronicFormat* v13_ElectronicFormat, IfcCalendarDate* v14_ValidFrom, IfcCalendarDate* v15_ValidUntil, boost::optional< IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum > v16_Confidentiality, boost::optional< IfcDocumentStatusEnum::IfcDocumentStatusEnum > v17_Status); @@ -8117,13 +7523,7 @@ public: /// Describes the type of relationship between documents. This could be sub-document, replacement etc. The interpretation has to be established in an application context. std::string RelationshipType() const; void setRelationshipType(std::string v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDocumentInformation; case 1: return Type::IfcDocumentInformation; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelatingDocument"; case 1: return "RelatedDocuments"; case 2: return "RelationshipType"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDocumentInformationRelationship (IfcAbstractEntity* e); IfcDocumentInformationRelationship (IfcDocumentInformation* v1_RelatingDocument, IfcTemplatedEntityList< IfcDocumentInformation >::ptr v2_RelatedDocuments, boost::optional< std::string > v3_RelationshipType); @@ -8144,13 +7544,7 @@ public: void setRelatingDraughtingCallout(IfcDraughtingCallout* v); IfcDraughtingCallout* RelatedDraughtingCallout() const; void setRelatedDraughtingCallout(IfcDraughtingCallout* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcDraughtingCallout; case 3: return Type::IfcDraughtingCallout; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "RelatingDraughtingCallout"; case 3: return "RelatedDraughtingCallout"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDraughtingCalloutRelationship (IfcAbstractEntity* e); IfcDraughtingCalloutRelationship (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDraughtingCallout* v3_RelatingDraughtingCallout, IfcDraughtingCallout* v4_RelatedDraughtingCallout); @@ -8167,13 +7561,7 @@ public: bool hasUserDefinedCategory() const; std::string UserDefinedCategory() const; void setUserDefinedCategory(std::string v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENUMERATION; case 8: return IfcUtil::Argument_STRING; } return IfcAppliedValue::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcLabel; case 7: return Type::IfcEnvironmentalImpactCategoryEnum; case 8: return Type::IfcLabel; } return IfcAppliedValue::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "ImpactType"; case 7: return "Category"; case 8: return "UserDefinedCategory"; } return IfcAppliedValue::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEnvironmentalImpactValue (IfcAbstractEntity* e); IfcEnvironmentalImpactValue (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcAppliedValueSelect* v3_AppliedValue, IfcMeasureWithUnit* v4_UnitBasis, IfcDateTimeSelect* v5_ApplicableDate, IfcDateTimeSelect* v6_FixedUntilDate, std::string v7_ImpactType, IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum v8_Category, boost::optional< std::string > v9_UserDefinedCategory); @@ -8206,13 +7594,7 @@ public: /// Optional name to further specify the reference. It can provide a human readable identifier (which does not necessarily need to have a counterpart in the internal structure of the document). std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcIdentifier; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Location"; case 1: return "ItemReference"; case 2: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExternalReference (IfcAbstractEntity* e); IfcExternalReference (boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name); @@ -8228,13 +7610,7 @@ public: /// HISTORY: New entity in IFC2x2. class IfcExternallyDefinedHatchStyle : public IfcExternalReference { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcExternalReference::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcExternalReference::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcExternalReference::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExternallyDefinedHatchStyle (IfcAbstractEntity* e); IfcExternallyDefinedHatchStyle (boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name); @@ -8249,13 +7625,7 @@ public: /// IFC2x3 CHANGE  The spelling has been corrected from IfcExternallyDefinedSufaceStyle with no upward compatibility. class IfcExternallyDefinedSurfaceStyle : public IfcExternalReference { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcExternalReference::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcExternalReference::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcExternalReference::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExternallyDefinedSurfaceStyle (IfcAbstractEntity* e); IfcExternallyDefinedSurfaceStyle (boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name); @@ -8272,13 +7642,7 @@ public: /// HISTORY New entity in IFC2x2. class IfcExternallyDefinedSymbol : public IfcExternalReference { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcExternalReference::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcExternalReference::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcExternalReference::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExternallyDefinedSymbol (IfcAbstractEntity* e); IfcExternallyDefinedSymbol (boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name); @@ -8293,13 +7657,7 @@ public: /// HISTORY  New entity in IFC2x2. class IfcExternallyDefinedTextFont : public IfcExternalReference { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcExternalReference::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcExternalReference::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcExternalReference::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExternallyDefinedTextFont (IfcAbstractEntity* e); IfcExternallyDefinedTextFont (boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name); @@ -8341,17 +7699,11 @@ public: /// Defines whether the original sense of curve is used or whether it is reversed in the context of the grid axis. bool SameSense() const; void setSameSense(bool v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_BOOL; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcCurve; case 2: return Type::IfcBoolean; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "AxisTag"; case 1: return "AxisCurve"; case 2: return "SameSense"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcGrid >::ptr PartOfW() const; // INVERSE IfcGrid::WAxes + IfcTemplatedEntityList< IfcGrid >::ptr PartOfW() const; // INVERSE IfcGrid::WAxes IfcTemplatedEntityList< IfcGrid >::ptr PartOfV() const; // INVERSE IfcGrid::VAxes IfcTemplatedEntityList< IfcGrid >::ptr PartOfU() const; // INVERSE IfcGrid::UAxes IfcTemplatedEntityList< IfcVirtualGridIntersection >::ptr HasIntersections() const; // INVERSE IfcVirtualGridIntersection::IntersectingAxes - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGridAxis (IfcAbstractEntity* e); IfcGridAxis (boost::optional< std::string > v1_AxisTag, IfcCurve* v2_AxisCurve, bool v3_SameSense); @@ -8368,13 +7720,7 @@ public: /// A list of time-series values. At least one value is required. IfcEntityList::ptr ListValues() const; void setListValues(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDateTimeSelect; case 1: return Type::IfcValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TimeStamp"; case 1: return "ListValues"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcIrregularTimeSeriesValue (IfcAbstractEntity* e); IfcIrregularTimeSeriesValue (IfcDateTimeSelect* v1_TimeStamp, IfcEntityList::ptr v2_ListValues); @@ -8414,13 +7760,7 @@ public: bool hasLibraryReference() const; IfcTemplatedEntityList< IfcLibraryReference >::ptr LibraryReference() const; void setLibraryReference(IfcTemplatedEntityList< IfcLibraryReference >::ptr v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcLabel; case 2: return Type::IfcOrganization; case 3: return Type::IfcCalendarDate; case 4: return Type::IfcLibraryReference; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Version"; case 2: return "Publisher"; case 3: return "VersionDate"; case 4: return "LibraryReference"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLibraryInformation (IfcAbstractEntity* e); IfcLibraryInformation (std::string v1_Name, boost::optional< std::string > v2_Version, IfcOrganization* v3_Publisher, IfcCalendarDate* v4_VersionDate, boost::optional< IfcTemplatedEntityList< IfcLibraryReference >::ptr > v5_LibraryReference); @@ -8435,14 +7775,8 @@ public: /// IFC2x4 CHANGE  Description and Language attribute added; ReferencedLibrary attribute added (reversing previous ReferenceIntoLibrary inverse relationship). class IfcLibraryReference : public IfcExternalReference { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcExternalReference::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcExternalReference::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcExternalReference::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcLibraryInformation >::ptr ReferenceIntoLibrary() const; // INVERSE IfcLibraryInformation::LibraryReference - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcLibraryInformation >::ptr ReferenceIntoLibrary() const; // INVERSE IfcLibraryInformation::LibraryReference + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLibraryReference (IfcAbstractEntity* e); IfcLibraryReference (boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name); @@ -8476,13 +7810,7 @@ public: /// The luminous intensity distribution measure for this pair of main and secondary plane angles according to the light distribution curve chosen. std::vector< double > /*[1:?]*/ LuminousIntensity() const; void setLuminousIntensity(std::vector< double > /*[1:?]*/ v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; case 2: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPlaneAngleMeasure; case 1: return Type::IfcPlaneAngleMeasure; case 2: return Type::IfcLuminousIntensityDistributionMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MainPlaneAngle"; case 1: return "SecondaryPlaneAngle"; case 2: return "LuminousIntensity"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLightDistributionData (IfcAbstractEntity* e); IfcLightDistributionData (double v1_MainPlaneAngle, std::vector< double > /*[1:?]*/ v2_SecondaryPlaneAngle, std::vector< double > /*[1:?]*/ v3_LuminousIntensity); @@ -8499,13 +7827,7 @@ public: /// Light distribution data applied to the light source. It is defined by a list of main plane angles (B or C according to the light distribution curve chosen) that includes (for each B or C angle) a second list of secondary plane angles (the β or γ angles) and the according luminous intensity distribution measures. IfcTemplatedEntityList< IfcLightDistributionData >::ptr DistributionData() const; void setDistributionData(IfcTemplatedEntityList< IfcLightDistributionData >::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLightDistributionCurveEnum; case 1: return Type::IfcLightDistributionData; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LightDistributionCurve"; case 1: return "DistributionData"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLightIntensityDistribution (IfcAbstractEntity* e); IfcLightIntensityDistribution (IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum v1_LightDistributionCurve, IfcTemplatedEntityList< IfcLightDistributionData >::ptr v2_DistributionData); @@ -8532,13 +7854,7 @@ public: bool hasDaylightSavingOffset() const; int DaylightSavingOffset() const; void setDaylightSavingOffset(int v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_INT; case 1: return IfcUtil::Argument_INT; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_INT; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcHourInDay; case 1: return Type::IfcMinuteInHour; case 2: return Type::IfcSecondInMinute; case 3: return Type::IfcCoordinatedUniversalTimeOffset; case 4: return Type::IfcDaylightSavingHour; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "HourComponent"; case 1: return "MinuteComponent"; case 2: return "SecondComponent"; case 3: return "Zone"; case 4: return "DaylightSavingOffset"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLocalTime (IfcAbstractEntity* e); IfcLocalTime (int v1_HourComponent, boost::optional< int > v2_MinuteComponent, boost::optional< double > v3_SecondComponent, IfcCoordinatedUniversalTimeOffset* v4_Zone, boost::optional< int > v5_DaylightSavingOffset); @@ -8580,15 +7896,9 @@ public: /// NOTE Material grade may have diffenrent meaning in different view definitions, e.g. strength grade for structural design and analysis, or visible appearance grade in architectural application. Also, more elaborate material grade definition may be associated as classification via inverse attribute HasExternalReferences. std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcMaterialDefinitionRepresentation >::ptr HasRepresentation() const; // INVERSE IfcMaterialDefinitionRepresentation::RepresentedMaterial + IfcTemplatedEntityList< IfcMaterialDefinitionRepresentation >::ptr HasRepresentation() const; // INVERSE IfcMaterialDefinitionRepresentation::RepresentedMaterial IfcTemplatedEntityList< IfcMaterialClassificationRelationship >::ptr ClassifiedAs() const; // INVERSE IfcMaterialClassificationRelationship::ClassifiedMaterial - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterial (IfcAbstractEntity* e); IfcMaterial (std::string v1_Name); @@ -8607,13 +7917,7 @@ public: /// Material being classified. IfcMaterial* ClassifiedMaterial() const; void setClassifiedMaterial(IfcMaterial* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcClassificationNotationSelect; case 1: return Type::IfcMaterial; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MaterialClassifications"; case 1: return "ClassifiedMaterial"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialClassificationRelationship (IfcAbstractEntity* e); IfcMaterialClassificationRelationship (IfcEntityList::ptr v1_MaterialClassifications, IfcMaterial* v2_ClassifiedMaterial); @@ -8665,14 +7969,8 @@ public: /// set to FALSE if the material layer is a solid material layer (the default). bool IsVentilated() const; void setIsVentilated(bool v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_BOOL; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterial; case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcLogical; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Material"; case 1: return "LayerThickness"; case 2: return "IsVentilated"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcMaterialLayerSet >::ptr ToMaterialLayerSet() const; // INVERSE IfcMaterialLayerSet::MaterialLayers - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcMaterialLayerSet >::ptr ToMaterialLayerSet() const; // INVERSE IfcMaterialLayerSet::MaterialLayers + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialLayer (IfcAbstractEntity* e); IfcMaterialLayer (IfcMaterial* v1_Material, double v2_LayerThickness, boost::optional< bool > v3_IsVentilated); @@ -8721,13 +8019,7 @@ public: /// The name by which the material layer set is known. std::string LayerSetName() const; void setLayerSetName(std::string v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterialLayer; case 1: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MaterialLayers"; case 1: return "LayerSetName"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialLayerSet (IfcAbstractEntity* e); IfcMaterialLayerSet (IfcTemplatedEntityList< IfcMaterialLayer >::ptr v1_MaterialLayers, boost::optional< std::string > v2_LayerSetName); @@ -8852,13 +8144,7 @@ public: /// Offset of the material layer set base line (MlsBase) from reference geometry (line or plane) of element. The offset can be positive or negative, unless restricted for a particular building element type in its use definition or by implementer agreement. A positive value means, that the MlsBase is placed on the positive side of the reference line or plane, on the axis established by LayerSetDirection (in case of AXIS2 into the direction of +y, or in case of AXIS2 into the direction of +z). A negative value means that the MlsBase is placed on the negative side, as established by LayerSetDirection (in case of AXIS2 into the direction of -y). NOTE  the positive or negative sign in the offset only affects the MlsBase placement, it does not have any effect on the application of DirectionSense for orientation of the material layers; also DirectionSense does not change the MlsBase placement. double OffsetFromReferenceLine() const; void setOffsetFromReferenceLine(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterialLayerSet; case 1: return Type::IfcLayerSetDirectionEnum; case 2: return Type::IfcDirectionSenseEnum; case 3: return Type::IfcLengthMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ForLayerSet"; case 1: return "LayerSetDirection"; case 2: return "DirectionSense"; case 3: return "OffsetFromReferenceLine"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialLayerSetUsage (IfcAbstractEntity* e); IfcMaterialLayerSetUsage (IfcMaterialLayerSet* v1_ForLayerSet, IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum v2_LayerSetDirection, IfcDirectionSenseEnum::IfcDirectionSenseEnum v3_DirectionSense, double v4_OffsetFromReferenceLine); @@ -8886,13 +8172,7 @@ public: /// Materials used in a composition of substances. IfcTemplatedEntityList< IfcMaterial >::ptr Materials() const; void setMaterials(IfcTemplatedEntityList< IfcMaterial >::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterial; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Materials"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialList (IfcAbstractEntity* e); IfcMaterialList (IfcTemplatedEntityList< IfcMaterial >::ptr v1_Materials); @@ -8927,13 +8207,7 @@ public: /// IFC2x4 CHANGE The datatype has been changed to supertype IfcMaterialDefinition. IfcMaterial* Material() const; void setMaterial(IfcMaterial* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterial; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Material"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialProperties (IfcAbstractEntity* e); IfcMaterialProperties (IfcMaterial* v1_Material); @@ -8957,13 +8231,7 @@ public: /// The unit in which the physical quantity is expressed. IfcUnit* UnitComponent() const; void setUnitComponent(IfcUnit* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; case 1: return Type::IfcUnit; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ValueComponent"; case 1: return "UnitComponent"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMeasureWithUnit (IfcAbstractEntity* e); IfcMeasureWithUnit (IfcValue* v1_ValueComponent, IfcUnit* v2_UnitComponent); @@ -8992,13 +8260,7 @@ public: bool hasThermalExpansionCoefficient() const; double ThermalExpansionCoefficient() const; void setThermalExpansionCoefficient(double v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; } return IfcMaterialProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcDynamicViscosityMeasure; case 2: return Type::IfcModulusOfElasticityMeasure; case 3: return Type::IfcModulusOfElasticityMeasure; case 4: return Type::IfcPositiveRatioMeasure; case 5: return Type::IfcThermalExpansionCoefficientMeasure; } return IfcMaterialProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "DynamicViscosity"; case 2: return "YoungModulus"; case 3: return "ShearModulus"; case 4: return "PoissonRatio"; case 5: return "ThermalExpansionCoefficient"; } return IfcMaterialProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMechanicalMaterialProperties (IfcAbstractEntity* e); IfcMechanicalMaterialProperties (IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient); @@ -9035,13 +8297,7 @@ public: bool hasRelaxations() const; IfcTemplatedEntityList< IfcRelaxation >::ptr Relaxations() const; void setRelaxations(IfcTemplatedEntityList< IfcRelaxation >::ptr v); - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcMechanicalMaterialProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcPressureMeasure; case 7: return Type::IfcPressureMeasure; case 8: return Type::IfcPositiveRatioMeasure; case 9: return Type::IfcModulusOfElasticityMeasure; case 10: return Type::IfcPressureMeasure; case 11: return Type::IfcPositiveRatioMeasure; case 12: return Type::IfcRelaxation; } return IfcMechanicalMaterialProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "YieldStress"; case 7: return "UltimateStress"; case 8: return "UltimateStrain"; case 9: return "HardeningModule"; case 10: return "ProportionalStress"; case 11: return "PlasticStrain"; case 12: return "Relaxations"; } return IfcMechanicalMaterialProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMechanicalSteelMaterialProperties (IfcAbstractEntity* e); IfcMechanicalSteelMaterialProperties (IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient, boost::optional< double > v7_YieldStress, boost::optional< double > v8_UltimateStress, boost::optional< double > v9_UltimateStrain, boost::optional< double > v10_HardeningModule, boost::optional< double > v11_ProportionalStress, boost::optional< double > v12_PlasticStrain, boost::optional< IfcTemplatedEntityList< IfcRelaxation >::ptr > v13_Relaxations); @@ -9112,13 +8368,7 @@ public: /// The value with data type defined by the underlying type accesses via IfcMetricValueSelect. IfcMetricValueSelect* DataValue() const; void setDataValue(IfcMetricValueSelect* v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_ENUMERATION; case 8: return IfcUtil::Argument_STRING; case 9: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcConstraint::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcBenchmarkEnum; case 8: return Type::IfcLabel; case 9: return Type::IfcMetricValueSelect; } return IfcConstraint::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "Benchmark"; case 8: return "ValueSource"; case 9: return "DataValue"; } return IfcConstraint::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMetric (IfcAbstractEntity* e); IfcMetric (std::string v1_Name, boost::optional< std::string > v2_Description, IfcConstraintEnum::IfcConstraintEnum v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, IfcActorSelect* v5_CreatingActor, IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, IfcBenchmarkEnum::IfcBenchmarkEnum v8_Benchmark, boost::optional< std::string > v9_ValueSource, IfcMetricValueSelect* v10_DataValue); @@ -9134,13 +8384,7 @@ public: /// Code or name of the currency. Permissible values are the three-letter alphabetic currency codes as per ISO 4217, for example CNY, EUR, GBP, JPY, USD. IfcCurrencyEnum::IfcCurrencyEnum Currency() const; void setCurrency(IfcCurrencyEnum::IfcCurrencyEnum v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCurrencyEnum; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Currency"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMonetaryUnit (IfcAbstractEntity* e); IfcMonetaryUnit (IfcCurrencyEnum::IfcCurrencyEnum v1_Currency); @@ -9159,13 +8403,7 @@ public: /// The type of the unit. IfcUnitEnum::IfcUnitEnum UnitType() const; void setUnitType(IfcUnitEnum::IfcUnitEnum v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENUMERATION; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDimensionalExponents; case 1: return Type::IfcUnitEnum; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Dimensions"; case 1: return "UnitType"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcNamedUnit (IfcAbstractEntity* e); IfcNamedUnit (IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType); @@ -9184,15 +8422,9 @@ public: /// HISTORY New entity in IFC Release 2x. class IfcObjectPlacement : public IfcUtil::IfcBaseEntity { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcProduct >::ptr PlacesObject() const; // INVERSE IfcProduct::ObjectPlacement + IfcTemplatedEntityList< IfcProduct >::ptr PlacesObject() const; // INVERSE IfcProduct::ObjectPlacement IfcTemplatedEntityList< IfcLocalPlacement >::ptr ReferencedByPlacements() const; // INVERSE IfcLocalPlacement::PlacementRelTo - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcObjectPlacement (IfcAbstractEntity* e); IfcObjectPlacement (); @@ -9227,13 +8459,7 @@ public: /// A user defined value that qualifies the type of objective constraint when ObjectiveQualifier attribute of type IfcObjectiveEnum has value USERDEFINED. std::string UserDefinedQualifier() const; void setUserDefinedQualifier(std::string v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_ENUMERATION; case 10: return IfcUtil::Argument_STRING; } return IfcConstraint::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcMetric; case 8: return Type::IfcMetric; case 9: return Type::IfcObjectiveEnum; case 10: return Type::IfcLabel; } return IfcConstraint::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "BenchmarkValues"; case 8: return "ResultValues"; case 9: return "ObjectiveQualifier"; case 10: return "UserDefinedQualifier"; } return IfcConstraint::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcObjective (IfcAbstractEntity* e); IfcObjective (std::string v1_Name, boost::optional< std::string > v2_Description, IfcConstraintEnum::IfcConstraintEnum v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, IfcActorSelect* v5_CreatingActor, IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, IfcMetric* v8_BenchmarkValues, IfcMetric* v9_ResultValues, IfcObjectiveEnum::IfcObjectiveEnum v10_ObjectiveQualifier, boost::optional< std::string > v11_UserDefinedQualifier); @@ -9278,13 +8504,7 @@ public: bool hasSolarReflectanceBack() const; double SolarReflectanceBack() const; void setSolarReflectanceBack(double v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; } return IfcMaterialProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcPositiveRatioMeasure; case 2: return Type::IfcPositiveRatioMeasure; case 3: return Type::IfcPositiveRatioMeasure; case 4: return Type::IfcPositiveRatioMeasure; case 5: return Type::IfcPositiveRatioMeasure; case 6: return Type::IfcPositiveRatioMeasure; case 7: return Type::IfcPositiveRatioMeasure; case 8: return Type::IfcPositiveRatioMeasure; case 9: return Type::IfcPositiveRatioMeasure; } return IfcMaterialProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "VisibleTransmittance"; case 2: return "SolarTransmittance"; case 3: return "ThermalIrTransmittance"; case 4: return "ThermalIrEmissivityBack"; case 5: return "ThermalIrEmissivityFront"; case 6: return "VisibleReflectanceBack"; case 7: return "VisibleReflectanceFront"; case 8: return "SolarReflectanceFront"; case 9: return "SolarReflectanceBack"; } return IfcMaterialProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOpticalMaterialProperties (IfcAbstractEntity* e); IfcOpticalMaterialProperties (IfcMaterial* v1_Material, boost::optional< double > v2_VisibleTransmittance, boost::optional< double > v3_SolarTransmittance, boost::optional< double > v4_ThermalIrTransmittance, boost::optional< double > v5_ThermalIrEmissivityBack, boost::optional< double > v6_ThermalIrEmissivityFront, boost::optional< double > v7_VisibleReflectanceBack, boost::optional< double > v8_VisibleReflectanceFront, boost::optional< double > v9_SolarReflectanceFront, boost::optional< double > v10_SolarReflectanceBack); @@ -9323,16 +8543,10 @@ public: /// NOTE: There may be several addresses related to an organization. IfcTemplatedEntityList< IfcAddress >::ptr Addresses() const; void setAddresses(IfcTemplatedEntityList< IfcAddress >::ptr v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcActorRole; case 4: return Type::IfcAddress; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Id"; case 1: return "Name"; case 2: return "Description"; case 3: return "Roles"; case 4: return "Addresses"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcOrganizationRelationship >::ptr IsRelatedBy() const; // INVERSE IfcOrganizationRelationship::RelatedOrganizations + IfcTemplatedEntityList< IfcOrganizationRelationship >::ptr IsRelatedBy() const; // INVERSE IfcOrganizationRelationship::RelatedOrganizations IfcTemplatedEntityList< IfcOrganizationRelationship >::ptr Relates() const; // INVERSE IfcOrganizationRelationship::RelatingOrganization IfcTemplatedEntityList< IfcPersonAndOrganization >::ptr Engages() const; // INVERSE IfcPersonAndOrganization::TheOrganization - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOrganization (IfcAbstractEntity* e); IfcOrganization (boost::optional< std::string > v1_Id, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< IfcTemplatedEntityList< IfcActorRole >::ptr > v4_Roles, boost::optional< IfcTemplatedEntityList< IfcAddress >::ptr > v5_Addresses); @@ -9360,13 +8574,7 @@ public: /// The other, possibly dependent, organizations which are the related parts of the relationship between organizations. IfcTemplatedEntityList< IfcOrganization >::ptr RelatedOrganizations() const; void setRelatedOrganizations(IfcTemplatedEntityList< IfcOrganization >::ptr v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcOrganization; case 3: return Type::IfcOrganization; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "RelatingOrganization"; case 3: return "RelatedOrganizations"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOrganizationRelationship (IfcAbstractEntity* e); IfcOrganizationRelationship (std::string v1_Name, boost::optional< std::string > v2_Description, IfcOrganization* v3_RelatingOrganization, IfcTemplatedEntityList< IfcOrganization >::ptr v4_RelatedOrganizations); @@ -9416,13 +8624,7 @@ public: /// The date and time expressed in UTC (Universal Time Coordinated, formerly Greenwich Mean Time or GMT) when first created by the original OwningApplication. Once defined this value remains unchanged through the lifetime of the entity. int CreationDate() const; void setCreationDate(int v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_ENUMERATION; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_INT; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPersonAndOrganization; case 1: return Type::IfcApplication; case 2: return Type::IfcStateEnum; case 3: return Type::IfcChangeActionEnum; case 4: return Type::IfcTimeStamp; case 5: return Type::IfcPersonAndOrganization; case 6: return Type::IfcApplication; case 7: return Type::IfcTimeStamp; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "OwningUser"; case 1: return "OwningApplication"; case 2: return "State"; case 3: return "ChangeAction"; case 4: return "LastModifiedDate"; case 5: return "LastModifyingUser"; case 6: return "LastModifyingApplication"; case 7: return "CreationDate"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOwnerHistory (IfcAbstractEntity* e); IfcOwnerHistory (IfcPersonAndOrganization* v1_OwningUser, IfcApplication* v2_OwningApplication, boost::optional< IfcStateEnum::IfcStateEnum > v3_State, IfcChangeActionEnum::IfcChangeActionEnum v4_ChangeAction, boost::optional< int > v5_LastModifiedDate, IfcPersonAndOrganization* v6_LastModifyingUser, IfcApplication* v7_LastModifyingApplication, int v8_CreationDate); @@ -9484,14 +8686,8 @@ public: /// NOTE - A person may have several addresses. IfcTemplatedEntityList< IfcAddress >::ptr Addresses() const; void setAddresses(IfcTemplatedEntityList< IfcAddress >::ptr v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 4: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 5: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 6: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcLabel; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcActorRole; case 7: return Type::IfcAddress; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Id"; case 1: return "FamilyName"; case 2: return "GivenName"; case 3: return "MiddleNames"; case 4: return "PrefixTitles"; case 5: return "SuffixTitles"; case 6: return "Roles"; case 7: return "Addresses"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcPersonAndOrganization >::ptr EngagedIn() const; // INVERSE IfcPersonAndOrganization::ThePerson - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcPersonAndOrganization >::ptr EngagedIn() const; // INVERSE IfcPersonAndOrganization::ThePerson + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPerson (IfcAbstractEntity* e); IfcPerson (boost::optional< std::string > v1_Id, boost::optional< std::string > v2_FamilyName, boost::optional< std::string > v3_GivenName, boost::optional< std::vector< std::string > /*[1:?]*/ > v4_MiddleNames, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_PrefixTitles, boost::optional< std::vector< std::string > /*[1:?]*/ > v6_SuffixTitles, boost::optional< IfcTemplatedEntityList< IfcActorRole >::ptr > v7_Roles, boost::optional< IfcTemplatedEntityList< IfcAddress >::ptr > v8_Addresses); @@ -9515,13 +8711,7 @@ public: /// Roles played by the person within the context of an organization. These may differ from the roles in ThePerson.Roles which may be asserted without organizational context. IfcTemplatedEntityList< IfcActorRole >::ptr Roles() const; void setRoles(IfcTemplatedEntityList< IfcActorRole >::ptr v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPerson; case 1: return Type::IfcOrganization; case 2: return Type::IfcActorRole; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ThePerson"; case 1: return "TheOrganization"; case 2: return "Roles"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPersonAndOrganization (IfcAbstractEntity* e); IfcPersonAndOrganization (IfcPerson* v1_ThePerson, IfcOrganization* v2_TheOrganization, boost::optional< IfcTemplatedEntityList< IfcActorRole >::ptr > v3_Roles); @@ -9542,14 +8732,8 @@ public: /// Further explanation that might be given to the quantity. std::string Description() const; void setDescription(std::string v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcPhysicalComplexQuantity >::ptr PartOfComplex() const; // INVERSE IfcPhysicalComplexQuantity::HasQuantities - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcPhysicalComplexQuantity >::ptr PartOfComplex() const; // INVERSE IfcPhysicalComplexQuantity::HasQuantities + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPhysicalQuantity (IfcAbstractEntity* e); IfcPhysicalQuantity (std::string v1_Name, boost::optional< std::string > v2_Description); @@ -9571,13 +8755,7 @@ public: /// Optional assignment of a unit. If no unit is given, then the global unit assignment, as established at the IfcProject, applies to the quantity measures. IfcNamedUnit* Unit() const; void setUnit(IfcNamedUnit* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPhysicalQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcNamedUnit; } return IfcPhysicalQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Unit"; } return IfcPhysicalQuantity::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPhysicalSimpleQuantity (IfcAbstractEntity* e); IfcPhysicalSimpleQuantity (std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit); @@ -9629,13 +8807,7 @@ public: /// The name of a country. std::string Country() const; void setCountry(std::string v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_STRING; case 9: return IfcUtil::Argument_STRING; } return IfcAddress::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcLabel; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcLabel; case 7: return Type::IfcLabel; case 8: return Type::IfcLabel; case 9: return Type::IfcLabel; } return IfcAddress::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "InternalLocation"; case 4: return "AddressLines"; case 5: return "PostalBox"; case 6: return "Town"; case 7: return "Region"; case 8: return "PostalCode"; case 9: return "Country"; } return IfcAddress::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPostalAddress (IfcAbstractEntity* e); IfcPostalAddress (boost::optional< IfcAddressTypeEnum::IfcAddressTypeEnum > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose, boost::optional< std::string > v4_InternalLocation, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_AddressLines, boost::optional< std::string > v6_PostalBox, boost::optional< std::string > v7_Town, boost::optional< std::string > v8_Region, boost::optional< std::string > v9_PostalCode, boost::optional< std::string > v10_Country); @@ -9653,13 +8825,7 @@ public: /// The string by which the pre defined item is identified. Allowable values for the string are declared at the level of subtypes. std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPreDefinedItem (IfcAbstractEntity* e); IfcPreDefinedItem (std::string v1_Name); @@ -9674,13 +8840,7 @@ public: /// HISTORY New entity in IFC2x2. class IfcPreDefinedSymbol : public IfcPreDefinedItem { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPreDefinedItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPreDefinedItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPreDefinedItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPreDefinedSymbol (IfcAbstractEntity* e); IfcPreDefinedSymbol (std::string v1_Name); @@ -9689,13 +8849,7 @@ public: class IfcPreDefinedTerminatorSymbol : public IfcPreDefinedSymbol { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPreDefinedSymbol::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPreDefinedSymbol::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPreDefinedSymbol::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPreDefinedTerminatorSymbol (IfcAbstractEntity* e); IfcPreDefinedTerminatorSymbol (std::string v1_Name); @@ -9714,13 +8868,7 @@ public: /// IFC2x3 CHANGE  The IfcTextStyleFontModel has been added as new subtype. class IfcPreDefinedTextFont : public IfcPreDefinedItem { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPreDefinedItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPreDefinedItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPreDefinedItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPreDefinedTextFont (IfcAbstractEntity* e); IfcPreDefinedTextFont (std::string v1_Name); @@ -9759,13 +8907,7 @@ public: /// An (internal) identifier assigned to the layer. std::string Identifier() const; void setIdentifier(std::string v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcLayeredItem; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "AssignedItems"; case 3: return "Identifier"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPresentationLayerAssignment (IfcAbstractEntity* e); IfcPresentationLayerAssignment (std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_AssignedItems, boost::optional< std::string > v4_Identifier); @@ -9802,13 +8944,7 @@ public: /// IFC2x4 CHANGE  The data type has been changed from IfcPresentationStyleSelect (now deprecated) to IfcPresentationStyle. IfcEntityList::ptr LayerStyles() const; void setLayerStyles(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_BOOL; case 5: return IfcUtil::Argument_BOOL; case 6: return IfcUtil::Argument_BOOL; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcPresentationLayerAssignment::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::UNDEFINED; case 5: return Type::UNDEFINED; case 6: return Type::UNDEFINED; case 7: return Type::IfcPresentationStyleSelect; } return IfcPresentationLayerAssignment::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "LayerOn"; case 5: return "LayerFrozen"; case 6: return "LayerBlocked"; case 7: return "LayerStyles"; } return IfcPresentationLayerAssignment::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPresentationLayerWithStyle (IfcAbstractEntity* e); IfcPresentationLayerWithStyle (std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_AssignedItems, boost::optional< std::string > v4_Identifier, bool v5_LayerOn, bool v6_LayerFrozen, bool v7_LayerBlocked, IfcEntityList::ptr v8_LayerStyles); @@ -9826,13 +8962,7 @@ public: /// Name of the presentation style. std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPresentationStyle (IfcAbstractEntity* e); IfcPresentationStyle (boost::optional< std::string > v1_Name); @@ -9848,13 +8978,7 @@ public: /// A set of presentation styles that are assigned to styled items. IfcEntityList::ptr Styles() const; void setStyles(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPresentationStyleSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Styles"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPresentationStyleAssignment (IfcAbstractEntity* e); IfcPresentationStyleAssignment (IfcEntityList::ptr v1_Styles); @@ -9892,13 +9016,7 @@ public: /// Contained list of representations (including shape representations). Each member defines a valid representation of a particular type within a particular representation context. IfcTemplatedEntityList< IfcRepresentation >::ptr Representations() const; void setRepresentations(IfcTemplatedEntityList< IfcRepresentation >::ptr v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcRepresentation; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "Representations"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProductRepresentation (IfcAbstractEntity* e); IfcProductRepresentation (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcRepresentation >::ptr v3_Representations); @@ -9923,13 +9041,7 @@ public: bool hasCO2Content() const; double CO2Content() const; void setCO2Content(double v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; } return IfcMaterialProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcSpecificHeatCapacityMeasure; case 2: return Type::IfcPositiveRatioMeasure; case 3: return Type::IfcPositiveRatioMeasure; case 4: return Type::IfcPositiveRatioMeasure; } return IfcMaterialProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "SpecificHeatCapacity"; case 2: return "N20Content"; case 3: return "COContent"; case 4: return "CO2Content"; } return IfcMaterialProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProductsOfCombustionProperties (IfcAbstractEntity* e); IfcProductsOfCombustionProperties (IfcMaterial* v1_Material, boost::optional< double > v2_SpecificHeatCapacity, boost::optional< double > v3_N20Content, boost::optional< double > v4_COContent, boost::optional< double > v5_CO2Content); @@ -10115,13 +9227,7 @@ public: /// Human-readable name of the profile, for example according to a standard profile table. As noted above, machine-readable standardized profile designations should be provided in IfcExternalReference.ItemReference. std::string ProfileName() const; void setProfileName(std::string v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcProfileTypeEnum; case 1: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ProfileType"; case 1: return "ProfileName"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProfileDef (IfcAbstractEntity* e); IfcProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName); @@ -10149,13 +9255,7 @@ public: /// Profile definition which is qualified by these properties. IfcProfileDef* ProfileDefinition() const; void setProfileDefinition(IfcProfileDef* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcProfileDef; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ProfileName"; case 1: return "ProfileDefinition"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProfileProperties (IfcAbstractEntity* e); IfcProfileProperties (boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition); @@ -10174,16 +9274,10 @@ public: /// Informative text to explain the property. std::string Description() const; void setDescription(std::string v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcPropertyDependencyRelationship >::ptr PropertyForDependance() const; // INVERSE IfcPropertyDependencyRelationship::DependingProperty + IfcTemplatedEntityList< IfcPropertyDependencyRelationship >::ptr PropertyForDependance() const; // INVERSE IfcPropertyDependencyRelationship::DependingProperty IfcTemplatedEntityList< IfcPropertyDependencyRelationship >::ptr PropertyDependsOn() const; // INVERSE IfcPropertyDependencyRelationship::DependantProperty IfcTemplatedEntityList< IfcComplexProperty >::ptr PartOfComplex() const; // INVERSE IfcComplexProperty::HasProperties - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProperty (IfcAbstractEntity* e); IfcProperty (std::string v1_Name, boost::optional< std::string > v2_Description); @@ -10204,13 +9298,7 @@ public: bool hasDescription() const; std::string Description() const; void setDescription(std::string v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcConstraint; case 1: return Type::IfcProperty; case 2: return Type::IfcLabel; case 3: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelatingConstraint"; case 1: return "RelatedProperties"; case 2: return "Name"; case 3: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyConstraintRelationship (IfcAbstractEntity* e); IfcPropertyConstraintRelationship (IfcConstraint* v1_RelatingConstraint, IfcTemplatedEntityList< IfcProperty >::ptr v2_RelatedProperties, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -10245,13 +9333,7 @@ public: /// Expression that further describes the nature of the dependency relation. std::string Expression() const; void setExpression(std::string v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcProperty; case 1: return Type::IfcProperty; case 2: return Type::IfcLabel; case 3: return Type::IfcText; case 4: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DependingProperty"; case 1: return "DependantProperty"; case 2: return "Name"; case 3: return "Description"; case 4: return "Expression"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyDependencyRelationship (IfcAbstractEntity* e); IfcPropertyDependencyRelationship (IfcProperty* v1_DependingProperty, IfcProperty* v2_DependantProperty, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_Expression); @@ -10316,13 +9398,7 @@ public: /// Unit for the enumerator values, if not given, the default value for the measure type (given by the TYPE of nominal value) is used as defined by the global unit assignment at IfcProject. IfcUnit* Unit() const; void setUnit(IfcUnit* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcValue; case 2: return Type::IfcUnit; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "EnumerationValues"; case 2: return "Unit"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyEnumeration (IfcAbstractEntity* e); IfcPropertyEnumeration (std::string v1_Name, IfcEntityList::ptr v2_EnumerationValues, IfcUnit* v3_Unit); @@ -10338,13 +9414,7 @@ public: /// Area measure value of this quantity. double AreaValue() const; void setAreaValue(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcAreaMeasure; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "AreaValue"; } return IfcPhysicalSimpleQuantity::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcQuantityArea (IfcAbstractEntity* e); IfcQuantityArea (std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_AreaValue); @@ -10360,13 +9430,7 @@ public: /// Count measure value of this quantity. double CountValue() const; void setCountValue(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcCountMeasure; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "CountValue"; } return IfcPhysicalSimpleQuantity::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcQuantityCount (IfcAbstractEntity* e); IfcQuantityCount (std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_CountValue); @@ -10382,13 +9446,7 @@ public: /// Length measure value of this quantity. double LengthValue() const; void setLengthValue(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcLengthMeasure; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "LengthValue"; } return IfcPhysicalSimpleQuantity::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcQuantityLength (IfcAbstractEntity* e); IfcQuantityLength (std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_LengthValue); @@ -10404,13 +9462,7 @@ public: /// Time measure value of this quantity. double TimeValue() const; void setTimeValue(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcTimeMeasure; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "TimeValue"; } return IfcPhysicalSimpleQuantity::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcQuantityTime (IfcAbstractEntity* e); IfcQuantityTime (std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_TimeValue); @@ -10426,13 +9478,7 @@ public: /// Volume measure value of this quantity. double VolumeValue() const; void setVolumeValue(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcVolumeMeasure; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "VolumeValue"; } return IfcPhysicalSimpleQuantity::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcQuantityVolume (IfcAbstractEntity* e); IfcQuantityVolume (std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_VolumeValue); @@ -10448,13 +9494,7 @@ public: /// Mass measure value of this quantity. double WeightValue() const; void setWeightValue(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcMassMeasure; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "WeightValue"; } return IfcPhysicalSimpleQuantity::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcQuantityWeight (IfcAbstractEntity* e); IfcQuantityWeight (std::string v1_Name, boost::optional< std::string > v2_Description, IfcNamedUnit* v3_Unit, double v4_WeightValue); @@ -10475,13 +9515,7 @@ public: bool hasDescription() const; std::string Description() const; void setDescription(std::string v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDocumentSelect; case 1: return Type::IfcAppliedValue; case 2: return Type::IfcLabel; case 3: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ReferencedDocument"; case 1: return "ReferencingValues"; case 2: return "Name"; case 3: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcReferencesValueDocument (IfcAbstractEntity* e); IfcReferencesValueDocument (IfcDocumentSelect* v1_ReferencedDocument, IfcTemplatedEntityList< IfcAppliedValue >::ptr v2_ReferencingValues, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -10520,13 +9554,7 @@ public: /// The number of bars with identical nominal diameter and steel grade included in the specific reinforcement configuration. double BarCount() const; void setBarCount(double v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAreaMeasure; case 1: return Type::IfcLabel; case 2: return Type::IfcReinforcingBarSurfaceEnum; case 3: return Type::IfcLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcCountMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TotalCrossSectionArea"; case 1: return "SteelGrade"; case 2: return "BarSurface"; case 3: return "EffectiveDepth"; case 4: return "NominalBarDiameter"; case 5: return "BarCount"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcReinforcementBarProperties (IfcAbstractEntity* e); IfcReinforcementBarProperties (double v1_TotalCrossSectionArea, std::string v2_SteelGrade, boost::optional< IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum > v3_BarSurface, boost::optional< double > v4_EffectiveDepth, boost::optional< double > v5_NominalBarDiameter, boost::optional< double > v6_BarCount); @@ -10539,13 +9567,7 @@ public: void setRelaxationValue(double v); double InitialStress() const; void setInitialStress(double v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcNormalisedRatioMeasure; case 1: return Type::IfcNormalisedRatioMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RelaxationValue"; case 1: return "InitialStress"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelaxation (IfcAbstractEntity* e); IfcRelaxation (double v1_RelaxationValue, double v2_InitialStress); @@ -10616,16 +9638,10 @@ public: /// Set of geometric representation items that are defined for this representation. IfcTemplatedEntityList< IfcRepresentationItem >::ptr Items() const; void setItems(IfcTemplatedEntityList< IfcRepresentationItem >::ptr v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRepresentationContext; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcRepresentationItem; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ContextOfItems"; case 1: return "RepresentationIdentifier"; case 2: return "RepresentationType"; case 3: return "Items"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRepresentationMap >::ptr RepresentationMap() const; // INVERSE IfcRepresentationMap::MappedRepresentation + IfcTemplatedEntityList< IfcRepresentationMap >::ptr RepresentationMap() const; // INVERSE IfcRepresentationMap::MappedRepresentation IfcTemplatedEntityList< IfcPresentationLayerAssignment >::ptr LayerAssignments() const; // INVERSE IfcPresentationLayerAssignment::AssignedItems IfcTemplatedEntityList< IfcProductRepresentation >::ptr OfProductRepresentation() const; // INVERSE IfcProductRepresentation::Representations - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRepresentation (IfcAbstractEntity* e); IfcRepresentation (IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items); @@ -10653,14 +9669,8 @@ public: /// The description of the type of a representation context. The supported values for context type are to be specified by implementers agreements. std::string ContextType() const; void setContextType(std::string v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ContextIdentifier"; case 1: return "ContextType"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRepresentation >::ptr RepresentationsInContext() const; // INVERSE IfcRepresentation::ContextOfItems - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRepresentation >::ptr RepresentationsInContext() const; // INVERSE IfcRepresentation::ContextOfItems + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRepresentationContext (IfcAbstractEntity* e); IfcRepresentationContext (boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType); @@ -10700,15 +9710,9 @@ public: /// IFC2x3 CHANGE  The inverse attributes StyledByItem and LayerAssignments have been added. Upward compatibility for file based exchange is guaranteed. class IfcRepresentationItem : public IfcUtil::IfcBaseEntity { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcPresentationLayerAssignment >::ptr LayerAssignments() const; // INVERSE IfcPresentationLayerAssignment::AssignedItems + IfcTemplatedEntityList< IfcPresentationLayerAssignment >::ptr LayerAssignments() const; // INVERSE IfcPresentationLayerAssignment::AssignedItems IfcTemplatedEntityList< IfcStyledItem >::ptr StyledByItem() const; // INVERSE IfcStyledItem::Item - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRepresentationItem (IfcAbstractEntity* e); IfcRepresentationItem (); @@ -10734,14 +9738,8 @@ public: /// A representation that is mapped to at least one mapped item. IfcRepresentation* MappedRepresentation() const; void setMappedRepresentation(IfcRepresentation* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAxis2Placement; case 1: return Type::IfcRepresentation; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MappingOrigin"; case 1: return "MappedRepresentation"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcMappedItem >::ptr MapUsage() const; // INVERSE IfcMappedItem::MappingSource - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcMappedItem >::ptr MapUsage() const; // INVERSE IfcMappedItem::MappingSource + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRepresentationMap (IfcAbstractEntity* e); IfcRepresentationMap (IfcAxis2Placement* v1_MappingOrigin, IfcRepresentation* v2_MappedRepresentation); @@ -10768,13 +9766,7 @@ public: void setRibSpacing(double v); IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum Direction() const; void setDirection(IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_ENUMERATION; } return IfcProfileProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcPositiveLengthMeasure; case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcRibPlateDirectionEnum; } return IfcProfileProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Thickness"; case 3: return "RibHeight"; case 4: return "RibWidth"; case 5: return "RibSpacing"; case 6: return "Direction"; } return IfcProfileProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRibPlateProfileProperties (IfcAbstractEntity* e); IfcRibPlateProfileProperties (boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_Thickness, boost::optional< double > v4_RibHeight, boost::optional< double > v5_RibWidth, boost::optional< double > v6_RibSpacing, IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum v7_Direction); @@ -10811,13 +9803,7 @@ public: /// Optional description, provided for exchanging informative comments. std::string Description() const; void setDescription(std::string v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGloballyUniqueId; case 1: return Type::IfcOwnerHistory; case 2: return Type::IfcLabel; case 3: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "GlobalId"; case 1: return "OwnerHistory"; case 2: return "Name"; case 3: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRoot (IfcAbstractEntity* e); IfcRoot (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -10842,13 +9828,7 @@ public: /// NOTE  Even though the SI system's base unit for mass is kilogram, the IfcSIUnit for mass is gram if no Prefix is asserted. IfcSIUnitName::IfcSIUnitName Name() const; void setName(IfcSIUnitName::IfcSIUnitName v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_ENUMERATION; } return IfcNamedUnit::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcSIPrefix; case 3: return Type::IfcSIUnitName; } return IfcNamedUnit::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Prefix"; case 3: return "Name"; } return IfcNamedUnit::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSIUnit (IfcAbstractEntity* e); IfcSIUnit (IfcUnitEnum::IfcUnitEnum v2_UnitType, boost::optional< IfcSIPrefix::IfcSIPrefix > v3_Prefix, IfcSIUnitName::IfcSIUnitName v4_Name); @@ -10872,13 +9852,7 @@ public: /// The cross section profile at the end point of the longitudinal section. IfcProfileDef* EndProfile() const; void setEndProfile(IfcProfileDef* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcSectionTypeEnum; case 1: return Type::IfcProfileDef; case 2: return Type::IfcProfileDef; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SectionType"; case 1: return "StartProfile"; case 2: return "EndProfile"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSectionProperties (IfcAbstractEntity* e); IfcSectionProperties (IfcSectionTypeEnum::IfcSectionTypeEnum v1_SectionType, IfcProfileDef* v2_StartProfile, IfcProfileDef* v3_EndProfile); @@ -10913,13 +9887,7 @@ public: /// The set of reinforcment properties attached to a section reinforcement properties definition. IfcTemplatedEntityList< IfcReinforcementBarProperties >::ptr CrossSectionReinforcementDefinitions() const; void setCrossSectionReinforcementDefinitions(IfcTemplatedEntityList< IfcReinforcementBarProperties >::ptr v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_ENUMERATION; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLengthMeasure; case 1: return Type::IfcLengthMeasure; case 2: return Type::IfcLengthMeasure; case 3: return Type::IfcReinforcingBarRoleEnum; case 4: return Type::IfcSectionProperties; case 5: return Type::IfcReinforcementBarProperties; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LongitudinalStartPosition"; case 1: return "LongitudinalEndPosition"; case 2: return "TransversePosition"; case 3: return "ReinforcementRole"; case 4: return "SectionDefinition"; case 5: return "CrossSectionReinforcementDefinitions"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSectionReinforcementProperties (IfcAbstractEntity* e); IfcSectionReinforcementProperties (double v1_LongitudinalStartPosition, double v2_LongitudinalEndPosition, boost::optional< double > v3_TransversePosition, IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum v4_ReinforcementRole, IfcSectionProperties* v5_SectionDefinition, IfcTemplatedEntityList< IfcReinforcementBarProperties >::ptr v6_CrossSectionReinforcementDefinitions); @@ -10987,13 +9955,7 @@ public: /// Reference to the product definition shape of which this class is an aspect. IfcProductDefinitionShape* PartOfProductDefinitionShape() const; void setPartOfProductDefinitionShape(IfcProductDefinitionShape* v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_BOOL; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcShapeModel; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::UNDEFINED; case 4: return Type::IfcProductDefinitionShape; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ShapeRepresentations"; case 1: return "Name"; case 2: return "Description"; case 3: return "ProductDefinitional"; case 4: return "PartOfProductDefinitionShape"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcShapeAspect (IfcAbstractEntity* e); IfcShapeAspect (IfcTemplatedEntityList< IfcShapeModel >::ptr v1_ShapeRepresentations, boost::optional< std::string > v2_Name, boost::optional< std::string > v3_Description, bool v4_ProductDefinitional, IfcProductDefinitionShape* v5_PartOfProductDefinitionShape); @@ -11019,14 +9981,8 @@ public: /// HISTORY  New entity in IFC2x3. class IfcShapeModel : public IfcRepresentation { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRepresentation::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRepresentation::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRepresentation::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcShapeAspect >::ptr OfShapeAspect() const; // INVERSE IfcShapeAspect::ShapeRepresentations - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcShapeAspect >::ptr OfShapeAspect() const; // INVERSE IfcShapeAspect::ShapeRepresentations + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcShapeModel (IfcAbstractEntity* e); IfcShapeModel (IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items); @@ -11169,13 +10125,7 @@ public: /// IFC2x4 CHANGE  The RepresentationType's 'Curve3D', 'Surface2D', 'Surface3D', 'AdvancedBrep', 'LightSource', and the RepresentationIdentifier 'Lighting' have been added. class IfcShapeRepresentation : public IfcShapeModel { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcShapeModel::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcShapeModel::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcShapeModel::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcShapeRepresentation (IfcAbstractEntity* e); IfcShapeRepresentation (IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items); @@ -11186,13 +10136,7 @@ public: /// HISTORY  New Entity in IFC Release 1.0, definition changed in IFC Release 2x. class IfcSimpleProperty : public IfcProperty { public: - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcProperty::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcProperty::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcProperty::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSimpleProperty (IfcAbstractEntity* e); IfcSimpleProperty (std::string v1_Name, boost::optional< std::string > v2_Description); @@ -11208,13 +10152,7 @@ public: /// Optionally defines a name for this connection condition. std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralConnectionCondition (IfcAbstractEntity* e); IfcStructuralConnectionCondition (boost::optional< std::string > v1_Name); @@ -11230,13 +10168,7 @@ public: /// Optionally defines a name for this load. std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLoad (IfcAbstractEntity* e); IfcStructuralLoad (boost::optional< std::string > v1_Name); @@ -11247,13 +10179,7 @@ public: /// HISTORY: New entity in IFC 2x2. class IfcStructuralLoadStatic : public IfcStructuralLoad { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralLoad::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralLoad::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralLoad::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLoadStatic (IfcAbstractEntity* e); IfcStructuralLoadStatic (boost::optional< std::string > v1_Name); @@ -11278,13 +10204,7 @@ public: bool hasDeltaT_Z() const; double DeltaT_Z() const; void setDeltaT_Z(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcStructuralLoadStatic::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcThermodynamicTemperatureMeasure; case 2: return Type::IfcThermodynamicTemperatureMeasure; case 3: return Type::IfcThermodynamicTemperatureMeasure; } return IfcStructuralLoadStatic::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "DeltaT_Constant"; case 2: return "DeltaT_Y"; case 3: return "DeltaT_Z"; } return IfcStructuralLoadStatic::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLoadTemperature (IfcAbstractEntity* e); IfcStructuralLoadTemperature (boost::optional< std::string > v1_Name, boost::optional< double > v2_DeltaT_Constant, boost::optional< double > v3_DeltaT_Y, boost::optional< double > v4_DeltaT_Z); @@ -11297,13 +10217,7 @@ public: /// HISTORY  New entity in IFC2x3. class IfcStyleModel : public IfcRepresentation { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRepresentation::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRepresentation::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRepresentation::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStyleModel (IfcAbstractEntity* e); IfcStyleModel (IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items); @@ -11359,13 +10273,7 @@ public: /// The word, or group of words, by which the styled item is referred to. std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; } return IfcRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRepresentationItem; case 1: return Type::IfcPresentationStyleAssignment; case 2: return Type::IfcLabel; } return IfcRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Item"; case 1: return "Styles"; case 2: return "Name"; } return IfcRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStyledItem (IfcAbstractEntity* e); IfcStyledItem (IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name); @@ -11380,13 +10288,7 @@ public: /// HISTORY  New entity in IFC2x2. class IfcStyledRepresentation : public IfcStyleModel { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStyleModel::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStyleModel::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStyleModel::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStyledRepresentation (IfcAbstractEntity* e); IfcStyledRepresentation (IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items); @@ -11407,13 +10309,7 @@ public: /// A collection of different surface styles. IfcEntityList::ptr Styles() const; void setStyles(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcPresentationStyle::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcSurfaceSide; case 2: return Type::IfcSurfaceStyleElementSelect; } return IfcPresentationStyle::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Side"; case 2: return "Styles"; } return IfcPresentationStyle::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceStyle (IfcAbstractEntity* e); IfcSurfaceStyle (boost::optional< std::string > v1_Name, IfcSurfaceSide::IfcSurfaceSide v2_Side, IfcEntityList::ptr v3_Styles); @@ -11448,13 +10344,7 @@ public: /// The factor can be measured physically and has three ratios for the red, green and blue part of the light. IfcColourRgb* ReflectanceColour() const; void setReflectanceColour(IfcColourRgb* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcColourRgb; case 1: return Type::IfcColourRgb; case 2: return Type::IfcColourRgb; case 3: return Type::IfcColourRgb; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DiffuseTransmissionColour"; case 1: return "DiffuseReflectionColour"; case 2: return "TransmissionColour"; case 3: return "ReflectanceColour"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceStyleLighting (IfcAbstractEntity* e); IfcSurfaceStyleLighting (IfcColourRgb* v1_DiffuseTransmissionColour, IfcColourRgb* v2_DiffuseReflectionColour, IfcColourRgb* v3_TransmissionColour, IfcColourRgb* v4_ReflectanceColour); @@ -11477,13 +10367,7 @@ public: /// The Abbe constant given as a fixed ratio between the refractive indices of the material at different wavelengths. A low Abbe number means a high dispersive power. In general this translates to a greater angular spread of the emergent spectrum. double DispersionFactor() const; void setDispersionFactor(double v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcReal; case 1: return Type::IfcReal; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RefractionIndex"; case 1: return "DispersionFactor"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceStyleRefraction (IfcAbstractEntity* e); IfcSurfaceStyleRefraction (boost::optional< double > v1_RefractionIndex, boost::optional< double > v2_DispersionFactor); @@ -11501,13 +10385,7 @@ public: /// The colour used to render the surface. The surface colour for visualisation is defined by specifying the intensity of red, green and blue. IfcColourRgb* SurfaceColour() const; void setSurfaceColour(IfcColourRgb* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcColourRgb; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SurfaceColour"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceStyleShading (IfcAbstractEntity* e); IfcSurfaceStyleShading (IfcColourRgb* v1_SurfaceColour); @@ -11536,13 +10414,7 @@ public: /// The textures applied to the surface. In case of more than one surface texture is included, the IfcSurfaceStyleWithTexture defines a multi texture. IfcTemplatedEntityList< IfcSurfaceTexture >::ptr Textures() const; void setTextures(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcSurfaceTexture; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Textures"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceStyleWithTextures (IfcAbstractEntity* e); IfcSurfaceStyleWithTextures (IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Textures); @@ -11657,13 +10529,7 @@ public: /// Mirroring is not allowed to be used in the IfcCarteesianTransformationOperator IfcCartesianTransformationOperator2D* TextureTransform() const; void setTextureTransform(IfcCartesianTransformationOperator2D* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_BOOL; case 1: return IfcUtil::Argument_BOOL; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::UNDEFINED; case 1: return Type::UNDEFINED; case 2: return Type::IfcSurfaceTextureEnum; case 3: return Type::IfcCartesianTransformationOperator2D; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RepeatS"; case 1: return "RepeatT"; case 2: return "TextureType"; case 3: return "TextureTransform"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceTexture (IfcAbstractEntity* e); IfcSurfaceTexture (bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform); @@ -11679,13 +10545,7 @@ public: /// The style applied to the symbol for its visual appearance. IfcSymbolStyleSelect* StyleOfSymbol() const; void setStyleOfSymbol(IfcSymbolStyleSelect* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPresentationStyle::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcSymbolStyleSelect; } return IfcPresentationStyle::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "StyleOfSymbol"; } return IfcPresentationStyle::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSymbolStyle (IfcAbstractEntity* e); IfcSymbolStyle (boost::optional< std::string > v1_Name, IfcSymbolStyleSelect* v2_StyleOfSymbol); @@ -11714,13 +10574,7 @@ public: /// Reference to information content of rows. IfcTemplatedEntityList< IfcTableRow >::ptr Rows() const; void setRows(IfcTemplatedEntityList< IfcTableRow >::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::UNDEFINED; case 1: return Type::IfcTableRow; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Rows"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTable (IfcAbstractEntity* e); IfcTable (std::string v1_Name, IfcTemplatedEntityList< IfcTableRow >::ptr v2_Rows); @@ -11747,14 +10601,8 @@ public: /// Flag which identifies if the row is a heading row or a row which contains row values. NOTE - If the row is a heading, the flag takes the value = TRUE. bool IsHeading() const; void setIsHeading(bool v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_BOOL; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; case 1: return Type::UNDEFINED; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RowCells"; case 1: return "IsHeading"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcTable >::ptr OfTable() const; // INVERSE IfcTable::Rows - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcTable >::ptr OfTable() const; // INVERSE IfcTable::Rows + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTableRow (IfcAbstractEntity* e); IfcTableRow (IfcEntityList::ptr v1_RowCells, bool v2_IsHeading); @@ -11796,13 +10644,7 @@ public: /// all such information may be referenced from a single page that is termed the home page for that person or organization. std::string WWWHomePageURL() const; void setWWWHomePageURL(std::string v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 4: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 7: return IfcUtil::Argument_STRING; } return IfcAddress::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcLabel; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcLabel; case 7: return Type::IfcLabel; } return IfcAddress::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "TelephoneNumbers"; case 4: return "FacsimileNumbers"; case 5: return "PagerNumber"; case 6: return "ElectronicMailAddresses"; case 7: return "WWWHomePageURL"; } return IfcAddress::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTelecomAddress (IfcAbstractEntity* e); IfcTelecomAddress (boost::optional< IfcAddressTypeEnum::IfcAddressTypeEnum > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose, boost::optional< std::vector< std::string > /*[1:?]*/ > v4_TelephoneNumbers, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_FacsimileNumbers, boost::optional< std::string > v6_PagerNumber, boost::optional< std::vector< std::string > /*[1:?]*/ > v7_ElectronicMailAddresses, boost::optional< std::string > v8_WWWHomePageURL); @@ -11857,13 +10699,7 @@ public: /// IFC2x Edition 2 Addendum 2 CHANGE The attribute TextFontStyle is a new attribute attached to IfcTextStyle. IfcTextFontSelect* TextFontStyle() const; void setTextFontStyle(IfcTextFontSelect* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPresentationStyle::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcCharacterStyleSelect; case 2: return Type::IfcTextStyleSelect; case 3: return Type::IfcTextFontSelect; } return IfcPresentationStyle::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "TextCharacterAppearance"; case 2: return "TextStyle"; case 3: return "TextFontStyle"; } return IfcPresentationStyle::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextStyle (IfcAbstractEntity* e); IfcTextStyle (boost::optional< std::string > v1_Name, IfcCharacterStyleSelect* v2_TextCharacterAppearance, IfcTextStyleSelect* v3_TextStyle, IfcTextFontSelect* v4_TextFontStyle); @@ -11962,13 +10798,7 @@ public: /// NOTE  The following values are allowed, getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextStyleFontModel (IfcAbstractEntity* e); IfcTextStyleFontModel (std::string v1_Name, boost::optional< std::vector< std::string > /*[1:?]*/ > v2_FontFamily, boost::optional< std::string > v3_FontStyle, boost::optional< std::string > v4_FontVariant, boost::optional< std::string > v5_FontWeight, IfcSizeSelect* v6_FontSize); @@ -12001,13 +10831,7 @@ public: /// This property sets the background color of an element. IfcColour* BackgroundColour() const; void setBackgroundColour(IfcColour* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcColour; case 1: return Type::IfcColour; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Colour"; case 1: return "BackgroundColour"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextStyleForDefinedFont (IfcAbstractEntity* e); IfcTextStyleForDefinedFont (IfcColour* v1_Colour, IfcColour* v2_BackgroundColour); @@ -12064,13 +10888,7 @@ public: /// IfcLengthMeasure, with non-negative values, the length unit is globally defined at IfcUnitAssignment, or IfcRatioMeasure. IfcSizeSelect* LineHeight() const; void setLineHeight(IfcSizeSelect* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcSizeSelect; case 1: return Type::IfcTextAlignment; case 2: return Type::IfcTextDecoration; case 3: return Type::IfcSizeSelect; case 4: return Type::IfcSizeSelect; case 5: return Type::IfcTextTransformation; case 6: return Type::IfcSizeSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TextIndent"; case 1: return "TextAlign"; case 2: return "TextDecoration"; case 3: return "LetterSpacing"; case 4: return "WordSpacing"; case 5: return "TextTransform"; case 6: return "LineHeight"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextStyleTextModel (IfcAbstractEntity* e); IfcTextStyleTextModel (IfcSizeSelect* v1_TextIndent, boost::optional< std::string > v2_TextAlign, boost::optional< std::string > v3_TextDecoration, IfcSizeSelect* v4_LetterSpacing, IfcSizeSelect* v5_WordSpacing, boost::optional< std::string > v6_TextTransform, IfcSizeSelect* v7_LineHeight); @@ -12120,13 +10938,7 @@ public: /// The distance between the character boxes of adjacent characters. IfcSizeSelect* CharacterSpacing() const; void setCharacterSpacing(IfcSizeSelect* v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPositiveLengthMeasure; case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcPlaneAngleMeasure; case 3: return Type::IfcPlaneAngleMeasure; case 4: return Type::IfcSizeSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BoxHeight"; case 1: return "BoxWidth"; case 2: return "BoxSlantAngle"; case 3: return "BoxRotateAngle"; case 4: return "CharacterSpacing"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextStyleWithBoxCharacteristics (IfcAbstractEntity* e); IfcTextStyleWithBoxCharacteristics (boost::optional< double > v1_BoxHeight, boost::optional< double > v2_BoxWidth, boost::optional< double > v3_BoxSlantAngle, boost::optional< double > v4_BoxRotateAngle, IfcSizeSelect* v5_CharacterSpacing); @@ -12145,14 +10957,8 @@ public: /// IFC2x4 CHANGE  The inverse attribute AnnotatedSurface is deleted, and the inverse AppliesTextures is added. class IfcTextureCoordinate : public IfcUtil::IfcBaseEntity { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcAnnotationSurface >::ptr AnnotatedSurface() const; // INVERSE IfcAnnotationSurface::TextureCoordinates - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcAnnotationSurface >::ptr AnnotatedSurface() const; // INVERSE IfcAnnotationSurface::TextureCoordinates + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextureCoordinate (IfcAbstractEntity* e); IfcTextureCoordinate (); @@ -12196,13 +11002,7 @@ public: /// IFC2x4 CHANGE  Made optional data type restricted to REAL. IfcEntityList::ptr Parameter() const; void setParameter(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcTextureCoordinate::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcSimpleValue; } return IfcTextureCoordinate::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Mode"; case 1: return "Parameter"; } return IfcTextureCoordinate::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextureCoordinateGenerator (IfcAbstractEntity* e); IfcTextureCoordinateGenerator (std::string v1_Mode, IfcEntityList::ptr v2_Parameter); @@ -12263,13 +11063,7 @@ class IfcTextureMap : public IfcTextureCoordinate { public: IfcTemplatedEntityList< IfcVertexBasedTextureMap >::ptr TextureMaps() const; void setTextureMaps(IfcTemplatedEntityList< IfcVertexBasedTextureMap >::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcTextureCoordinate::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcVertexBasedTextureMap; } return IfcTextureCoordinate::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TextureMaps"; } return IfcTextureCoordinate::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextureMap (IfcAbstractEntity* e); IfcTextureMap (IfcTemplatedEntityList< IfcVertexBasedTextureMap >::ptr v1_TextureMaps); @@ -12307,13 +11101,7 @@ public: /// The first coordinate[1] is the S, the second coordinate[2] is the T parameter value. std::vector< double > /*[2:2]*/ Coordinates() const; void setCoordinates(std::vector< double > /*[2:2]*/ v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcParameterValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Coordinates"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextureVertex (IfcAbstractEntity* e); IfcTextureVertex (std::vector< double > /*[2:2]*/ v1_Coordinates); @@ -12338,13 +11126,7 @@ public: bool hasThermalConductivity() const; double ThermalConductivity() const; void setThermalConductivity(double v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; } return IfcMaterialProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcSpecificHeatCapacityMeasure; case 2: return Type::IfcThermodynamicTemperatureMeasure; case 3: return Type::IfcThermodynamicTemperatureMeasure; case 4: return Type::IfcThermalConductivityMeasure; } return IfcMaterialProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "SpecificHeatCapacity"; case 2: return "BoilingPoint"; case 3: return "FreezingPoint"; case 4: return "ThermalConductivity"; } return IfcMaterialProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcThermalMaterialProperties (IfcAbstractEntity* e); IfcThermalMaterialProperties (IfcMaterial* v1_Material, boost::optional< double > v2_SpecificHeatCapacity, boost::optional< double > v3_BoilingPoint, boost::optional< double > v4_FreezingPoint, boost::optional< double > v5_ThermalConductivity); @@ -12387,14 +11169,8 @@ public: /// The unit to be assigned to all values within the time series. Note that mixing units is not allowed. If the value is not given, the global unit for the type of IfcValue, as defined at IfcProject.UnitsInContext is used. IfcUnit* Unit() const; void setUnit(IfcUnit* v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcDateTimeSelect; case 3: return Type::IfcDateTimeSelect; case 4: return Type::IfcTimeSeriesDataTypeEnum; case 5: return Type::IfcDataOriginEnum; case 6: return Type::IfcLabel; case 7: return Type::IfcUnit; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "StartTime"; case 3: return "EndTime"; case 4: return "TimeSeriesDataType"; case 5: return "DataOrigin"; case 6: return "UserDefinedDataOrigin"; case 7: return "Unit"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcTimeSeriesReferenceRelationship >::ptr DocumentedBy() const; // INVERSE IfcTimeSeriesReferenceRelationship::ReferencedTimeSeries - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcTimeSeriesReferenceRelationship >::ptr DocumentedBy() const; // INVERSE IfcTimeSeriesReferenceRelationship::ReferencedTimeSeries + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTimeSeries (IfcAbstractEntity* e); IfcTimeSeries (std::string v1_Name, boost::optional< std::string > v2_Description, IfcDateTimeSelect* v3_StartTime, IfcDateTimeSelect* v4_EndTime, IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v5_TimeSeriesDataType, IfcDataOriginEnum::IfcDataOriginEnum v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, IfcUnit* v8_Unit); @@ -12407,13 +11183,7 @@ public: void setReferencedTimeSeries(IfcTimeSeries* v); IfcEntityList::ptr TimeSeriesReferences() const; void setTimeSeriesReferences(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcTimeSeries; case 1: return Type::IfcDocumentSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ReferencedTimeSeries"; case 1: return "TimeSeriesReferences"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTimeSeriesReferenceRelationship (IfcAbstractEntity* e); IfcTimeSeriesReferenceRelationship (IfcTimeSeries* v1_ReferencedTimeSeries, IfcEntityList::ptr v2_TimeSeriesReferences); @@ -12433,13 +11203,7 @@ public: /// A list of time-series values. At least one value is required. IfcEntityList::ptr ListValues() const; void setListValues(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ListValues"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTimeSeriesValue (IfcAbstractEntity* e); IfcTimeSeriesValue (IfcEntityList::ptr v1_ListValues); @@ -12452,13 +11216,7 @@ public: /// HISTORY: New entity in IFC Release 1.5 class IfcTopologicalRepresentationItem : public IfcRepresentationItem { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTopologicalRepresentationItem (IfcAbstractEntity* e); IfcTopologicalRepresentationItem (); @@ -12500,13 +11258,7 @@ public: /// HISTORY: New entity in IFC 2x2. class IfcTopologyRepresentation : public IfcShapeModel { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcShapeModel::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcShapeModel::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcShapeModel::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTopologyRepresentation (IfcAbstractEntity* e); IfcTopologyRepresentation (IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, IfcTemplatedEntityList< IfcRepresentationItem >::ptr v4_Items); @@ -12522,13 +11274,7 @@ public: /// Units to be included within a unit assignment. IfcEntityList::ptr Units() const; void setUnits(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcUnit; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Units"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcUnitAssignment (IfcAbstractEntity* e); IfcUnitAssignment (IfcEntityList::ptr v1_Units); @@ -12546,13 +11292,7 @@ public: /// The extent of a vertex is defined to be zero. class IfcVertex : public IfcTopologicalRepresentationItem { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcTopologicalRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcTopologicalRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcTopologicalRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcVertex (IfcAbstractEntity* e); IfcVertex (); @@ -12565,13 +11305,7 @@ public: void setTextureVertices(IfcTemplatedEntityList< IfcTextureVertex >::ptr v); IfcTemplatedEntityList< IfcCartesianPoint >::ptr TexturePoints() const; void setTexturePoints(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcTextureVertex; case 1: return Type::IfcCartesianPoint; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TextureVertices"; case 1: return "TexturePoints"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcVertexBasedTextureMap (IfcAbstractEntity* e); IfcVertexBasedTextureMap (IfcTemplatedEntityList< IfcTextureVertex >::ptr v1_TextureVertices, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_TexturePoints); @@ -12591,13 +11325,7 @@ public: /// The geometric point, which defines the position in geometric space of the vertex. IfcPoint* VertexGeometry() const; void setVertexGeometry(IfcPoint* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcVertex::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPoint; } return IfcVertex::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "VertexGeometry"; } return IfcVertex::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcVertexPoint (IfcAbstractEntity* e); IfcVertexPoint (IfcPoint* v1_VertexGeometry); @@ -12670,13 +11398,7 @@ public: /// Offset distances to the grid axes. If given, it defines virtual offset curves to the grid axes. The intersection of the offset curves specify the virtual grid intersection. std::vector< double > /*[2:3]*/ OffsetDistances() const; void setOffsetDistances(std::vector< double > /*[2:3]*/ v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGridAxis; case 1: return Type::IfcLengthMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "IntersectingAxes"; case 1: return "OffsetDistances"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcVirtualGridIntersection (IfcAbstractEntity* e); IfcVirtualGridIntersection (IfcTemplatedEntityList< IfcGridAxis >::ptr v1_IntersectingAxes, std::vector< double > /*[2:3]*/ v2_OffsetDistances); @@ -12713,13 +11435,7 @@ public: bool hasDissolvedSolidsContent() const; double DissolvedSolidsContent() const; void setDissolvedSolidsContent(double v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_BOOL; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; } return IfcMaterialProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::UNDEFINED; case 2: return Type::IfcIonConcentrationMeasure; case 3: return Type::IfcIonConcentrationMeasure; case 4: return Type::IfcIonConcentrationMeasure; case 5: return Type::IfcNormalisedRatioMeasure; case 6: return Type::IfcPHMeasure; case 7: return Type::IfcNormalisedRatioMeasure; } return IfcMaterialProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "IsPotable"; case 2: return "Hardness"; case 3: return "AlkalinityConcentration"; case 4: return "AcidityConcentration"; case 5: return "ImpuritiesContent"; case 6: return "PHLevel"; case 7: return "DissolvedSolidsContent"; } return IfcMaterialProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWaterProperties (IfcAbstractEntity* e); IfcWaterProperties (IfcMaterial* v1_Material, boost::optional< bool > v2_IsPotable, boost::optional< double > v3_Hardness, boost::optional< double > v4_AlkalinityConcentration, boost::optional< double > v5_AcidityConcentration, boost::optional< double > v6_ImpuritiesContent, boost::optional< double > v7_PHLevel, boost::optional< double > v8_DissolvedSolidsContent); @@ -12728,13 +11444,7 @@ public: class IfcAnnotationOccurrence : public IfcStyledItem { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStyledItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStyledItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStyledItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAnnotationOccurrence (IfcAbstractEntity* e); IfcAnnotationOccurrence (IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name); @@ -12743,13 +11453,7 @@ public: class IfcAnnotationSurfaceOccurrence : public IfcAnnotationOccurrence { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAnnotationSurfaceOccurrence (IfcAbstractEntity* e); IfcAnnotationSurfaceOccurrence (IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name); @@ -12758,13 +11462,7 @@ public: class IfcAnnotationSymbolOccurrence : public IfcAnnotationOccurrence { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAnnotationSymbolOccurrence (IfcAbstractEntity* e); IfcAnnotationSymbolOccurrence (IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name); @@ -12773,13 +11471,7 @@ public: class IfcAnnotationTextOccurrence : public IfcAnnotationOccurrence { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAnnotationTextOccurrence (IfcAbstractEntity* e); IfcAnnotationTextOccurrence (IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name); @@ -12808,13 +11500,7 @@ public: /// Bounded curve, defining the outer boundaries of the arbitrary profile. IfcCurve* OuterCurve() const; void setOuterCurve(IfcCurve* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcCurve; } return IfcProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "OuterCurve"; } return IfcProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcArbitraryClosedProfileDef (IfcAbstractEntity* e); IfcArbitraryClosedProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcCurve* v3_OuterCurve); @@ -12840,13 +11526,7 @@ public: /// Open bounded curve defining the profile. IfcBoundedCurve* Curve() const; void setCurve(IfcBoundedCurve* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcBoundedCurve; } return IfcProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Curve"; } return IfcProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcArbitraryOpenProfileDef (IfcAbstractEntity* e); IfcArbitraryOpenProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcBoundedCurve* v3_Curve); @@ -12876,13 +11556,7 @@ public: /// Set of bounded curves, defining the inner boundaries of the arbitrary profile. IfcTemplatedEntityList< IfcCurve >::ptr InnerCurves() const; void setInnerCurves(IfcTemplatedEntityList< IfcCurve >::ptr v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcArbitraryClosedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcCurve; } return IfcArbitraryClosedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "InnerCurves"; } return IfcArbitraryClosedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcArbitraryProfileDefWithVoids (IfcAbstractEntity* e); IfcArbitraryProfileDefWithVoids (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcCurve* v3_OuterCurve, IfcTemplatedEntityList< IfcCurve >::ptr v4_InnerCurves); @@ -12905,13 +11579,7 @@ public: /// Blob, given as a single binary, to capture the texture within one popular file (compression) format. The file format is provided by the RasterFormat attribute. bool RasterCode() const; void setRasterCode(bool v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_BOOL; } return IfcSurfaceTexture::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcIdentifier; case 5: return Type::UNDEFINED; } return IfcSurfaceTexture::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RasterFormat"; case 5: return "RasterCode"; } return IfcSurfaceTexture::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBlobTexture (IfcAbstractEntity* e); IfcBlobTexture (bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform, std::string v5_RasterFormat, bool v6_RasterCode); @@ -12951,13 +11619,7 @@ public: /// Constant thickness applied along the center line. double Thickness() const; void setThickness(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; } return IfcArbitraryOpenProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; } return IfcArbitraryOpenProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "Thickness"; } return IfcArbitraryOpenProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCenterLineProfileDef (IfcAbstractEntity* e); IfcCenterLineProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcBoundedCurve* v3_Curve, double v4_Thickness); @@ -12991,13 +11653,7 @@ public: /// The classification system or source that is referenced. IfcClassification* ReferencedSource() const; void setReferencedSource(IfcClassification* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcExternalReference::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcClassification; } return IfcExternalReference::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "ReferencedSource"; } return IfcExternalReference::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcClassificationReference (IfcAbstractEntity* e); IfcClassificationReference (boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name, IfcClassification* v4_ReferencedSource); @@ -13028,13 +11684,7 @@ public: /// NOTE  The colour component value is given within the range of 0..1, and not within the range of 0..255 as otherwise usual. double Blue() const; void setBlue(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcColourSpecification::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcNormalisedRatioMeasure; case 2: return Type::IfcNormalisedRatioMeasure; case 3: return Type::IfcNormalisedRatioMeasure; } return IfcColourSpecification::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Red"; case 2: return "Green"; case 3: return "Blue"; } return IfcColourSpecification::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcColourRgb (IfcAbstractEntity* e); IfcColourRgb (boost::optional< std::string > v1_Name, double v2_Red, double v3_Green, double v4_Blue); @@ -13054,13 +11704,7 @@ public: /// Set of properties that can be used within this complex property (may include other complex properties). IfcTemplatedEntityList< IfcProperty >::ptr HasProperties() const; void setHasProperties(IfcTemplatedEntityList< IfcProperty >::ptr v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcProperty::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcIdentifier; case 3: return Type::IfcProperty; } return IfcProperty::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "UsageName"; case 3: return "HasProperties"; } return IfcProperty::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcComplexProperty (IfcAbstractEntity* e); IfcComplexProperty (std::string v1_Name, boost::optional< std::string > v2_Description, std::string v3_UsageName, IfcTemplatedEntityList< IfcProperty >::ptr v4_HasProperties); @@ -13112,13 +11756,7 @@ public: /// The name by which the composition may be referred to. The actual meaning of the name has to be defined in the context of applications. std::string Label() const; void setLabel(std::string v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_STRING; } return IfcProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcProfileDef; case 3: return Type::IfcLabel; } return IfcProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Profiles"; case 3: return "Label"; } return IfcProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCompositeProfileDef (IfcAbstractEntity* e); IfcCompositeProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcTemplatedEntityList< IfcProfileDef >::ptr v3_Profiles, boost::optional< std::string > v4_Label); @@ -13138,13 +11776,7 @@ public: /// The set of faces arcwise connected along common edges or vertices. IfcTemplatedEntityList< IfcFace >::ptr CfsFaces() const; void setCfsFaces(IfcTemplatedEntityList< IfcFace >::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcTopologicalRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcFace; } return IfcTopologicalRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "CfsFaces"; } return IfcTopologicalRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConnectedFaceSet (IfcAbstractEntity* e); IfcConnectedFaceSet (IfcTemplatedEntityList< IfcFace >::ptr v1_CfsFaces); @@ -13173,13 +11805,7 @@ public: /// The bounded curve at which the connected objects are aligned at the related element, given in the LCS of the related element. If the information is omitted, then the origin of the related element is used. IfcCurveOrEdgeCurve* CurveOnRelatedElement() const; void setCurveOnRelatedElement(IfcCurveOrEdgeCurve* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcConnectionGeometry::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCurveOrEdgeCurve; case 1: return Type::IfcCurveOrEdgeCurve; } return IfcConnectionGeometry::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "CurveOnRelatingElement"; case 1: return "CurveOnRelatedElement"; } return IfcConnectionGeometry::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConnectionCurveGeometry (IfcAbstractEntity* e); IfcConnectionCurveGeometry (IfcCurveOrEdgeCurve* v1_CurveOnRelatingElement, IfcCurveOrEdgeCurve* v2_CurveOnRelatedElement); @@ -13221,13 +11847,7 @@ public: /// Distance in z direction between the two points (or vertex points) engaged in the point connection. double EccentricityInZ() const; void setEccentricityInZ(double v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; } return IfcConnectionPointGeometry::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcLengthMeasure; case 3: return Type::IfcLengthMeasure; case 4: return Type::IfcLengthMeasure; } return IfcConnectionPointGeometry::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "EccentricityInX"; case 3: return "EccentricityInY"; case 4: return "EccentricityInZ"; } return IfcConnectionPointGeometry::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConnectionPointEccentricity (IfcAbstractEntity* e); IfcConnectionPointEccentricity (IfcPointOrVertexPoint* v1_PointOnRelatingElement, IfcPointOrVertexPoint* v2_PointOnRelatedElement, boost::optional< double > v3_EccentricityInX, boost::optional< double > v4_EccentricityInY, boost::optional< double > v5_EccentricityInZ); @@ -13245,13 +11865,7 @@ public: /// The word, or group of words, by which the context dependent unit is referred to. std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_STRING; } return IfcNamedUnit::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcLabel; } return IfcNamedUnit::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Name"; } return IfcNamedUnit::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcContextDependentUnit (IfcAbstractEntity* e); IfcContextDependentUnit (IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType, std::string v3_Name); @@ -13312,13 +11926,7 @@ public: /// The physical quantity from which the converted unit is derived. IfcMeasureWithUnit* ConversionFactor() const; void setConversionFactor(IfcMeasureWithUnit* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcNamedUnit::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcLabel; case 3: return Type::IfcMeasureWithUnit; } return IfcNamedUnit::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Name"; case 3: return "ConversionFactor"; } return IfcNamedUnit::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConversionBasedUnit (IfcAbstractEntity* e); IfcConversionBasedUnit (IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType, std::string v3_Name, IfcMeasureWithUnit* v4_ConversionFactor); @@ -13358,13 +11966,7 @@ public: /// The colour of the visible part of the curve. If not given, then the colour should be taken from the layer assignment with style, if that is not given either, then the default colour applies. IfcColour* CurveColour() const; void setCurveColour(IfcColour* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPresentationStyle::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcCurveFontOrScaledCurveFontSelect; case 2: return Type::IfcSizeSelect; case 3: return Type::IfcColour; } return IfcPresentationStyle::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "CurveFont"; case 2: return "CurveWidth"; case 3: return "CurveColour"; } return IfcPresentationStyle::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCurveStyle (IfcAbstractEntity* e); IfcCurveStyle (boost::optional< std::string > v1_Name, IfcCurveFontOrScaledCurveFontSelect* v2_CurveFont, IfcSizeSelect* v3_CurveWidth, IfcColour* v4_CurveColour); @@ -13467,13 +12069,7 @@ public: /// The name by which the transformation may be referred to. The actual meaning of the name has to be defined in the context of applications. std::string Label() const; void setLabel(std::string v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; } return IfcProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcProfileDef; case 3: return Type::IfcCartesianTransformationOperator2D; case 4: return Type::IfcLabel; } return IfcProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "ParentProfile"; case 3: return "Operator"; case 4: return "Label"; } return IfcProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDerivedProfileDef (IfcAbstractEntity* e); IfcDerivedProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcProfileDef* v3_ParentProfile, IfcCartesianTransformationOperator2D* v4_Operator, boost::optional< std::string > v5_Label); @@ -13482,13 +12078,7 @@ public: class IfcDimensionCalloutRelationship : public IfcDraughtingCalloutRelationship { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDraughtingCalloutRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDraughtingCalloutRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDraughtingCalloutRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDimensionCalloutRelationship (IfcAbstractEntity* e); IfcDimensionCalloutRelationship (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDraughtingCallout* v3_RelatingDraughtingCallout, IfcDraughtingCallout* v4_RelatedDraughtingCallout); @@ -13497,13 +12087,7 @@ public: class IfcDimensionPair : public IfcDraughtingCalloutRelationship { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDraughtingCalloutRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDraughtingCalloutRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDraughtingCalloutRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDimensionPair (IfcAbstractEntity* e); IfcDimensionPair (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDraughtingCallout* v3_RelatingDraughtingCallout, IfcDraughtingCallout* v4_RelatedDraughtingCallout); @@ -13522,14 +12106,8 @@ public: /// Modified in IFC 2x. class IfcDocumentReference : public IfcExternalReference { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcExternalReference::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcExternalReference::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcExternalReference::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcDocumentInformation >::ptr ReferenceToDocument() const; // INVERSE IfcDocumentInformation::DocumentReferences - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcDocumentInformation >::ptr ReferenceToDocument() const; // INVERSE IfcDocumentInformation::DocumentReferences + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDocumentReference (IfcAbstractEntity* e); IfcDocumentReference (boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name); @@ -13547,13 +12125,7 @@ public: /// HISTORY  New entity in IFC2x2. class IfcDraughtingPreDefinedTextFont : public IfcPreDefinedTextFont { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPreDefinedTextFont::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPreDefinedTextFont::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPreDefinedTextFont::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDraughtingPreDefinedTextFont (IfcAbstractEntity* e); IfcDraughtingPreDefinedTextFont (std::string v1_Name); @@ -13616,13 +12188,7 @@ public: /// End point (vertex) of the edge. The same vertex can be used for both EdgeStart and EdgeEnd. IfcVertex* EdgeEnd() const; void setEdgeEnd(IfcVertex* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcTopologicalRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcVertex; case 1: return Type::IfcVertex; } return IfcTopologicalRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "EdgeStart"; case 1: return "EdgeEnd"; } return IfcTopologicalRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEdge (IfcAbstractEntity* e); IfcEdge (IfcVertex* v1_EdgeStart, IfcVertex* v2_EdgeEnd); @@ -13669,13 +12235,7 @@ public: /// This logical flag indicates whether (TRUE), or not (FALSE) the senses of the edge and the curve defining the edge geometry are the same. The sense of an edge is from the edge start vertex to the edge end vertex; the sense of a curve is in the direction of increasing parameter. bool SameSense() const; void setSameSense(bool v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_BOOL; } return IfcEdge::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcCurve; case 3: return Type::UNDEFINED; } return IfcEdge::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "EdgeGeometry"; case 3: return "SameSense"; } return IfcEdge::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEdgeCurve (IfcAbstractEntity* e); IfcEdgeCurve (IfcVertex* v1_EdgeStart, IfcVertex* v2_EdgeEnd, IfcCurve* v3_EdgeGeometry, bool v4_SameSense); @@ -13726,13 +12286,7 @@ public: void setDescription(std::string v); std::string Name() const; void setName(std::string v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } return IfcMaterialProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcProperty; case 2: return Type::IfcText; case 3: return Type::IfcLabel; } return IfcMaterialProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "ExtendedProperties"; case 2: return "Description"; case 3: return "Name"; } return IfcMaterialProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExtendedMaterialProperties (IfcAbstractEntity* e); IfcExtendedMaterialProperties (IfcMaterial* v1_Material, IfcTemplatedEntityList< IfcProperty >::ptr v2_ExtendedProperties, boost::optional< std::string > v3_Description, std::string v4_Name); @@ -13787,13 +12341,7 @@ public: /// Boundaries of the face. IfcTemplatedEntityList< IfcFaceBound >::ptr Bounds() const; void setBounds(IfcTemplatedEntityList< IfcFaceBound >::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcTopologicalRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcFaceBound; } return IfcTopologicalRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Bounds"; } return IfcTopologicalRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFace (IfcAbstractEntity* e); IfcFace (IfcTemplatedEntityList< IfcFaceBound >::ptr v1_Bounds); @@ -13812,13 +12360,7 @@ public: /// This indicated whether (TRUE) or not (FALSE) the loop has the same sense when used to bound the face as when first defined. If sense is FALSE the senses of all its component oriented edges are implicitly reversed when used in the face. bool Orientation() const; void setOrientation(bool v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_BOOL; } return IfcTopologicalRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLoop; case 1: return Type::UNDEFINED; } return IfcTopologicalRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Bound"; case 1: return "Orientation"; } return IfcTopologicalRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFaceBound (IfcAbstractEntity* e); IfcFaceBound (IfcLoop* v1_Bound, bool v2_Orientation); @@ -13831,13 +12373,7 @@ public: /// HISTORY New class in IFC Release 1.0 class IfcFaceOuterBound : public IfcFaceBound { public: - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcFaceBound::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcFaceBound::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcFaceBound::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFaceOuterBound (IfcAbstractEntity* e); IfcFaceOuterBound (IfcLoop* v1_Bound, bool v2_Orientation); @@ -13887,13 +12423,7 @@ public: /// This flag indicates whether the sense of the surface normal agrees with (TRUE), or opposes (FALSE), the sense of the topological normal to the face. bool SameSense() const; void setSameSense(bool v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_BOOL; } return IfcFace::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcSurface; case 2: return Type::UNDEFINED; } return IfcFace::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "FaceSurface"; case 2: return "SameSense"; } return IfcFace::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFaceSurface (IfcAbstractEntity* e); IfcFaceSurface (IfcTemplatedEntityList< IfcFaceBound >::ptr v1_Bounds, IfcSurface* v2_FaceSurface, bool v3_SameSense); @@ -13938,13 +12468,7 @@ public: /// Compression force in z-direction leading to failure of the connection. double CompressionFailureZ() const; void setCompressionFailureZ(double v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; } return IfcStructuralConnectionCondition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcForceMeasure; case 2: return Type::IfcForceMeasure; case 3: return Type::IfcForceMeasure; case 4: return Type::IfcForceMeasure; case 5: return Type::IfcForceMeasure; case 6: return Type::IfcForceMeasure; } return IfcStructuralConnectionCondition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "TensionFailureX"; case 2: return "TensionFailureY"; case 3: return "TensionFailureZ"; case 4: return "CompressionFailureX"; case 5: return "CompressionFailureY"; case 6: return "CompressionFailureZ"; } return IfcStructuralConnectionCondition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFailureConnectionCondition (IfcAbstractEntity* e); IfcFailureConnectionCondition (boost::optional< std::string > v1_Name, boost::optional< double > v2_TensionFailureX, boost::optional< double > v3_TensionFailureY, boost::optional< double > v4_TensionFailureZ, boost::optional< double > v5_CompressionFailureX, boost::optional< double > v6_CompressionFailureY, boost::optional< double > v7_CompressionFailureZ); @@ -13989,13 +12513,7 @@ public: /// The set of fill area styles to use in presenting visible curve segments, annotation fill areas or surfaces. IfcEntityList::ptr FillStyles() const; void setFillStyles(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcPresentationStyle::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcFillStyleSelect; } return IfcPresentationStyle::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "FillStyles"; } return IfcPresentationStyle::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFillAreaStyle (IfcAbstractEntity* e); IfcFillAreaStyle (boost::optional< std::string > v1_Name, IfcEntityList::ptr v2_FillStyles); @@ -14020,13 +12538,7 @@ public: bool hasHigherHeatingValue() const; double HigherHeatingValue() const; void setHigherHeatingValue(double v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; } return IfcMaterialProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcThermodynamicTemperatureMeasure; case 2: return Type::IfcPositiveRatioMeasure; case 3: return Type::IfcHeatingValueMeasure; case 4: return Type::IfcHeatingValueMeasure; } return IfcMaterialProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "CombustionTemperature"; case 2: return "CarbonContent"; case 3: return "LowerHeatingValue"; case 4: return "HigherHeatingValue"; } return IfcMaterialProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFuelProperties (IfcAbstractEntity* e); IfcFuelProperties (IfcMaterial* v1_Material, boost::optional< double > v2_CombustionTemperature, boost::optional< double > v3_CarbonContent, boost::optional< double > v4_LowerHeatingValue, boost::optional< double > v5_HigherHeatingValue); @@ -14047,13 +12559,7 @@ public: bool hasMassDensity() const; double MassDensity() const; void setMassDensity(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcMaterialProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcMolecularWeightMeasure; case 2: return Type::IfcNormalisedRatioMeasure; case 3: return Type::IfcMassDensityMeasure; } return IfcMaterialProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "MolecularWeight"; case 2: return "Porosity"; case 3: return "MassDensity"; } return IfcMaterialProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGeneralMaterialProperties (IfcAbstractEntity* e); IfcGeneralMaterialProperties (IfcMaterial* v1_Material, boost::optional< double > v2_MolecularWeight, boost::optional< double > v3_Porosity, boost::optional< double > v4_MassDensity); @@ -14082,13 +12588,7 @@ public: bool hasCrossSectionArea() const; double CrossSectionArea() const; void setCrossSectionArea(double v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; } return IfcProfileProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcMassPerLengthMeasure; case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcAreaMeasure; } return IfcProfileProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "PhysicalWeight"; case 3: return "Perimeter"; case 4: return "MinimumPlateThickness"; case 5: return "MaximumPlateThickness"; case 6: return "CrossSectionArea"; } return IfcProfileProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGeneralProfileProperties (IfcAbstractEntity* e); IfcGeneralProfileProperties (boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea); @@ -14161,14 +12661,8 @@ public: /// Direction of the true north, or geographic northing direction, relative to the underlying project coordinate system. It is given by a 2 dimensional direction within the xy-plane of the project coordinate system. If not resent, it defaults to 0. 1. - i.e. the positive Y axis of the project coordinate system equals the geographic northing direction. IfcDirection* TrueNorth() const; void setTrueNorth(IfcDirection* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_INT; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRepresentationContext::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcDimensionCount; case 3: return Type::UNDEFINED; case 4: return Type::IfcAxis2Placement; case 5: return Type::IfcDirection; } return IfcRepresentationContext::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "CoordinateSpaceDimension"; case 3: return "Precision"; case 4: return "WorldCoordinateSystem"; case 5: return "TrueNorth"; } return IfcRepresentationContext::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcGeometricRepresentationSubContext >::ptr HasSubContexts() const; // INVERSE IfcGeometricRepresentationSubContext::ParentContext - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcGeometricRepresentationSubContext >::ptr HasSubContexts() const; // INVERSE IfcGeometricRepresentationSubContext::ParentContext + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGeometricRepresentationContext (IfcAbstractEntity* e); IfcGeometricRepresentationContext (boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType, int v3_CoordinateSpaceDimension, boost::optional< double > v4_Precision, IfcAxis2Placement* v5_WorldCoordinateSystem, IfcDirection* v6_TrueNorth); @@ -14195,13 +12689,7 @@ public: /// HISTORY: New entity in IFC Release 1.5 class IfcGeometricRepresentationItem : public IfcRepresentationItem { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGeometricRepresentationItem (IfcAbstractEntity* e); IfcGeometricRepresentationItem (); @@ -14248,13 +12736,7 @@ public: /// User defined target view, this attribute value shall be given, if the TargetView attribute is set to USERDEFINED. std::string UserDefinedTargetView() const; void setUserDefinedTargetView(std::string v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_STRING; } return IfcGeometricRepresentationContext::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcGeometricRepresentationContext; case 7: return Type::IfcPositiveRatioMeasure; case 8: return Type::IfcGeometricProjectionEnum; case 9: return Type::IfcLabel; } return IfcGeometricRepresentationContext::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "ParentContext"; case 7: return "TargetScale"; case 8: return "TargetView"; case 9: return "UserDefinedTargetView"; } return IfcGeometricRepresentationContext::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGeometricRepresentationSubContext (IfcAbstractEntity* e); IfcGeometricRepresentationSubContext (boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType, IfcGeometricRepresentationContext* v7_ParentContext, boost::optional< double > v8_TargetScale, IfcGeometricProjectionEnum::IfcGeometricProjectionEnum v9_TargetView, boost::optional< std::string > v10_UserDefinedTargetView); @@ -14272,13 +12754,7 @@ public: /// The geometric elements which make up the geometric set, these may be points, curves or surfaces; but are required to be of the same coordinate space dimensionality. IfcEntityList::ptr Elements() const; void setElements(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGeometricSetSelect; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Elements"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGeometricSet (IfcAbstractEntity* e); IfcGeometricSet (IfcEntityList::ptr v1_Elements); @@ -14341,13 +12817,7 @@ public: /// IFC2x4 CHANGE The select of an explict direction has been added. IfcVirtualGridIntersection* PlacementRefDirection() const; void setPlacementRefDirection(IfcVirtualGridIntersection* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcObjectPlacement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcVirtualGridIntersection; case 1: return Type::IfcVirtualGridIntersection; } return IfcObjectPlacement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "PlacementLocation"; case 1: return "PlacementRefDirection"; } return IfcObjectPlacement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGridPlacement (IfcAbstractEntity* e); IfcGridPlacement (IfcVirtualGridIntersection* v1_PlacementLocation, IfcVirtualGridIntersection* v2_PlacementRefDirection); @@ -14376,13 +12846,7 @@ public: /// The agreement flag is TRUE if the normal to the BaseSurface points away from the material of the IfcHalfSpaceSolid. Otherwise it is FALSE. bool AgreementFlag() const; void setAgreementFlag(bool v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_BOOL; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcSurface; case 1: return Type::UNDEFINED; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BaseSurface"; case 1: return "AgreementFlag"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcHalfSpaceSolid (IfcAbstractEntity* e); IfcHalfSpaceSolid (IfcSurface* v1_BaseSurface, bool v2_AgreementFlag); @@ -14411,13 +12875,7 @@ public: bool hasMoistureDiffusivity() const; double MoistureDiffusivity() const; void setMoistureDiffusivity(double v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; } return IfcMaterialProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcPositiveRatioMeasure; case 2: return Type::IfcPositiveRatioMeasure; case 3: return Type::IfcIsothermalMoistureCapacityMeasure; case 4: return Type::IfcVaporPermeabilityMeasure; case 5: return Type::IfcMoistureDiffusivityMeasure; } return IfcMaterialProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "UpperVaporResistanceFactor"; case 2: return "LowerVaporResistanceFactor"; case 3: return "IsothermalMoistureCapacity"; case 4: return "VaporPermeability"; case 5: return "MoistureDiffusivity"; } return IfcMaterialProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcHygroscopicMaterialProperties (IfcAbstractEntity* e); IfcHygroscopicMaterialProperties (IfcMaterial* v1_Material, boost::optional< double > v2_UpperVaporResistanceFactor, boost::optional< double > v3_LowerVaporResistanceFactor, boost::optional< double > v4_IsothermalMoistureCapacity, boost::optional< double > v5_VaporPermeability, boost::optional< double > v6_MoistureDiffusivity); @@ -14462,13 +12920,7 @@ class IfcImageTexture : public IfcSurfaceTexture { public: std::string UrlReference() const; void setUrlReference(std::string v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_STRING; } return IfcSurfaceTexture::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcIdentifier; } return IfcSurfaceTexture::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "UrlReference"; } return IfcSurfaceTexture::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcImageTexture (IfcAbstractEntity* e); IfcImageTexture (bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform, std::string v5_UrlReference); @@ -14484,13 +12936,7 @@ public: /// The collection of time series values. IfcTemplatedEntityList< IfcIrregularTimeSeriesValue >::ptr Values() const; void setValues(IfcTemplatedEntityList< IfcIrregularTimeSeriesValue >::ptr v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcTimeSeries::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcIrregularTimeSeriesValue; } return IfcTimeSeries::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "Values"; } return IfcTimeSeries::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcIrregularTimeSeries (IfcAbstractEntity* e); IfcIrregularTimeSeries (std::string v1_Name, boost::optional< std::string > v2_Description, IfcDateTimeSelect* v3_StartTime, IfcDateTimeSelect* v4_EndTime, IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v5_TimeSeriesDataType, IfcDataOriginEnum::IfcDataOriginEnum v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, IfcUnit* v8_Unit, IfcTemplatedEntityList< IfcIrregularTimeSeriesValue >::ptr v9_Values); @@ -14524,13 +12970,7 @@ public: /// Definition from VRML97 - ISO/IEC 14772-1:1997: The intensity field specifies the brightness of the direct emission from the ligth. Light intensity may range from 0.0 (no light emission) to 1.0 (full intensity). double Intensity() const; void setIntensity(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcColourRgb; case 2: return Type::IfcNormalisedRatioMeasure; case 3: return Type::IfcNormalisedRatioMeasure; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "LightColour"; case 2: return "AmbientIntensity"; case 3: return "Intensity"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLightSource (IfcAbstractEntity* e); IfcLightSource (boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity); @@ -14545,13 +12985,7 @@ public: /// HISTORY: This is a new entity in IFC 2x, renamed and enhanced in IFC2x2. class IfcLightSourceAmbient : public IfcLightSource { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcLightSource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcLightSource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcLightSource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLightSourceAmbient (IfcAbstractEntity* e); IfcLightSourceAmbient (boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity); @@ -14572,13 +13006,7 @@ public: /// Definition from VRML97 - ISO/IEC 14772-1:1997: The direction field specifies the direction vector of the illumination emanating from the light source in the local coordinate system. Light is emitted along parallel rays from an infinite distance away. IfcDirection* Orientation() const; void setOrientation(IfcDirection* v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcLightSource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcDirection; } return IfcLightSource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "Orientation"; } return IfcLightSource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLightSourceDirectional (IfcAbstractEntity* e); IfcLightSourceDirectional (boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcDirection* v5_Orientation); @@ -14613,13 +13041,7 @@ public: /// The data source from which light distribution data is obtained. IfcLightDistributionDataSourceSelect* LightDistributionDataSource() const; void setLightDistributionDataSource(IfcLightDistributionDataSourceSelect* v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcLightSource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcAxis2Placement3D; case 5: return Type::IfcColourRgb; case 6: return Type::IfcThermodynamicTemperatureMeasure; case 7: return Type::IfcLuminousFluxMeasure; case 8: return Type::IfcLightEmissionSourceEnum; case 9: return Type::IfcLightDistributionDataSourceSelect; } return IfcLightSource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "Position"; case 5: return "ColourAppearance"; case 6: return "ColourTemperature"; case 7: return "LuminousFlux"; case 8: return "LightEmissionSource"; case 9: return "LightDistributionDataSource"; } return IfcLightSource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLightSourceGoniometric (IfcAbstractEntity* e); IfcLightSourceGoniometric (boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcAxis2Placement3D* v5_Position, IfcColourRgb* v6_ColourAppearance, double v7_ColourTemperature, double v8_LuminousFlux, IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum v9_LightEmissionSource, IfcLightDistributionDataSourceSelect* v10_LightDistributionDataSource); @@ -14659,13 +13081,7 @@ public: /// Definition from the IAI: This real indicates the value of the attenuation in the lighting equation that proportional to the square value of the distance from the light source. double QuadricAttenuation() const; void setQuadricAttenuation(double v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; } return IfcLightSource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcCartesianPoint; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcReal; case 7: return Type::IfcReal; case 8: return Type::IfcReal; } return IfcLightSource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "Position"; case 5: return "Radius"; case 6: return "ConstantAttenuation"; case 7: return "DistanceAttenuation"; case 8: return "QuadricAttenuation"; } return IfcLightSource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLightSourcePositional (IfcAbstractEntity* e); IfcLightSourcePositional (boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcCartesianPoint* v5_Position, double v6_Radius, double v7_ConstantAttenuation, double v8_DistanceAttenuation, double v9_QuadricAttenuation); @@ -14705,13 +13121,7 @@ public: /// Definition from VRML97 - ISO/IEC 14772-1:1997: The beamWidth field specifies an inner solid angle in which the light source emits light at uniform full intensity. The light source's emission intensity drops off from the inner solid angle (beamWidthAngle) to the outer solid angle (spreadAngle). double BeamWidthAngle() const; void setBeamWidthAngle(double v); - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_DOUBLE; } return IfcLightSourcePositional::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcDirection; case 10: return Type::IfcReal; case 11: return Type::IfcPositivePlaneAngleMeasure; case 12: return Type::IfcPositivePlaneAngleMeasure; } return IfcLightSourcePositional::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "Orientation"; case 10: return "ConcentrationExponent"; case 11: return "SpreadAngle"; case 12: return "BeamWidthAngle"; } return IfcLightSourcePositional::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLightSourceSpot (IfcAbstractEntity* e); IfcLightSourceSpot (boost::optional< std::string > v1_Name, IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, IfcCartesianPoint* v5_Position, double v6_Radius, double v7_ConstantAttenuation, double v8_DistanceAttenuation, double v9_QuadricAttenuation, IfcDirection* v10_Orientation, boost::optional< double > v11_ConcentrationExponent, double v12_SpreadAngle, double v13_BeamWidthAngle); @@ -14779,13 +13189,7 @@ public: /// Geometric placement that defines the transformation from the related coordinate system into the relating. The placement can be either 2D or 3D, depending on the dimension count of the coordinate system. IfcAxis2Placement* RelativePlacement() const; void setRelativePlacement(IfcAxis2Placement* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcObjectPlacement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcObjectPlacement; case 1: return Type::IfcAxis2Placement; } return IfcObjectPlacement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "PlacementRelTo"; case 1: return "RelativePlacement"; } return IfcObjectPlacement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLocalPlacement (IfcAbstractEntity* e); IfcLocalPlacement (IfcObjectPlacement* v1_PlacementRelTo, IfcAxis2Placement* v2_RelativePlacement); @@ -14819,13 +13223,7 @@ public: /// and end vertices. class IfcLoop : public IfcTopologicalRepresentationItem { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcTopologicalRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcTopologicalRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcTopologicalRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLoop (IfcAbstractEntity* e); IfcLoop (); @@ -14858,13 +13256,7 @@ public: /// A representation item that is the target onto which the mapping source is mapped. It is constraint to be a Cartesian transformation operator. IfcCartesianTransformationOperator* MappingTarget() const; void setMappingTarget(IfcCartesianTransformationOperator* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRepresentationMap; case 1: return Type::IfcCartesianTransformationOperator; } return IfcRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MappingSource"; case 1: return "MappingTarget"; } return IfcRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMappedItem (IfcAbstractEntity* e); IfcMappedItem (IfcRepresentationMap* v1_MappingSource, IfcCartesianTransformationOperator* v2_MappingTarget); @@ -14905,13 +13297,7 @@ public: /// Reference to the material to which the representation applies. IfcMaterial* RepresentedMaterial() const; void setRepresentedMaterial(IfcMaterial* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcProductRepresentation::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcMaterial; } return IfcProductRepresentation::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "RepresentedMaterial"; } return IfcProductRepresentation::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialDefinitionRepresentation (IfcAbstractEntity* e); IfcMaterialDefinitionRepresentation (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcRepresentation >::ptr v3_Representations, IfcMaterial* v4_RepresentedMaterial); @@ -14944,13 +13330,7 @@ public: bool hasWaterImpermeability() const; std::string WaterImpermeability() const; void setWaterImpermeability(std::string v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_STRING; case 9: return IfcUtil::Argument_STRING; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_STRING; } return IfcMechanicalMaterialProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcPressureMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcText; case 9: return Type::IfcText; case 10: return Type::IfcNormalisedRatioMeasure; case 11: return Type::IfcText; } return IfcMechanicalMaterialProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "CompressiveStrength"; case 7: return "MaxAggregateSize"; case 8: return "AdmixturesDescription"; case 9: return "Workability"; case 10: return "ProtectivePoreRatio"; case 11: return "WaterImpermeability"; } return IfcMechanicalMaterialProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMechanicalConcreteMaterialProperties (IfcAbstractEntity* e); IfcMechanicalConcreteMaterialProperties (IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient, boost::optional< double > v7_CompressiveStrength, boost::optional< double > v8_MaxAggregateSize, boost::optional< std::string > v9_AdmixturesDescription, boost::optional< std::string > v10_Workability, boost::optional< double > v11_ProtectivePoreRatio, boost::optional< std::string > v12_WaterImpermeability); @@ -15008,17 +13388,11 @@ public: /// IFC2x4 CHANGE The new subtype IfcContext and the relationship to context HasContext has been added . The decomposition relationship is split into ordered nesting (Nests, IsNestedBy) and un-ordered aggregating (Decomposes, IsDecomposedBy). class IfcObjectDefinition : public IfcRoot { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRoot::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRoot::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRoot::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssigns >::ptr HasAssignments() const; // INVERSE IfcRelAssigns::RelatedObjects + IfcTemplatedEntityList< IfcRelAssigns >::ptr HasAssignments() const; // INVERSE IfcRelAssigns::RelatedObjects IfcTemplatedEntityList< IfcRelDecomposes >::ptr IsDecomposedBy() const; // INVERSE IfcRelDecomposes::RelatingObject IfcTemplatedEntityList< IfcRelDecomposes >::ptr Decomposes() const; // INVERSE IfcRelDecomposes::RelatedObjects IfcTemplatedEntityList< IfcRelAssociates >::ptr HasAssociations() const; // INVERSE IfcRelAssociates::RelatedObjects - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcObjectDefinition (IfcAbstractEntity* e); IfcObjectDefinition (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -15036,13 +13410,7 @@ public: /// A vector which specifies the relative positioning of hatch lines. IfcVector* RepeatFactor() const; void setRepeatFactor(IfcVector* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcVector; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RepeatFactor"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOneDirectionRepeatFactor (IfcAbstractEntity* e); IfcOneDirectionRepeatFactor (IfcVector* v1_RepeatFactor); @@ -15109,13 +13477,7 @@ public: /// 10303-42:1994, p.148 for the equation. class IfcOpenShell : public IfcConnectedFaceSet { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcConnectedFaceSet::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcConnectedFaceSet::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcConnectedFaceSet::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOpenShell (IfcAbstractEntity* e); IfcOpenShell (IfcTemplatedEntityList< IfcFace >::ptr v1_CfsFaces); @@ -15136,13 +13498,7 @@ public: /// BOOLEAN, If TRUE the topological orientation as used coincides with the orientation from start vertex to end vertex of the edge element. If FALSE otherwise. bool Orientation() const; void setOrientation(bool v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_BOOL; } return IfcEdge::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcEdge; case 3: return Type::UNDEFINED; } return IfcEdge::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "EdgeElement"; case 3: return "Orientation"; } return IfcEdge::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOrientedEdge (IfcAbstractEntity* e); IfcOrientedEdge (IfcEdge* v3_EdgeElement, bool v4_Orientation); @@ -15195,13 +13551,7 @@ public: /// Position coordinate system of the parameterized profile definition. If unspecified, no translation and no rotation is applied. IfcAxis2Placement2D* Position() const; void setPosition(IfcAxis2Placement2D* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcAxis2Placement2D; } return IfcProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Position"; } return IfcProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcParameterizedProfileDef (IfcAbstractEntity* e); IfcParameterizedProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position); @@ -15226,13 +13576,7 @@ public: /// The list of oriented edges which are concatenated together to form this path. IfcTemplatedEntityList< IfcOrientedEdge >::ptr EdgeList() const; void setEdgeList(IfcTemplatedEntityList< IfcOrientedEdge >::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcTopologicalRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcOrientedEdge; } return IfcTopologicalRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "EdgeList"; } return IfcTopologicalRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPath (IfcAbstractEntity* e); IfcPath (IfcTemplatedEntityList< IfcOrientedEdge >::ptr v1_EdgeList); @@ -15265,13 +13609,7 @@ public: /// Additional indication of a usage type of the quantities that are grouped under this physical complex quantity. std::string Usage() const; void setUsage(std::string v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; } return IfcPhysicalQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcPhysicalQuantity; case 3: return Type::IfcLabel; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; } return IfcPhysicalQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "HasQuantities"; case 3: return "Discrimination"; case 4: return "Quality"; case 5: return "Usage"; } return IfcPhysicalQuantity::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPhysicalComplexQuantity (IfcAbstractEntity* e); IfcPhysicalComplexQuantity (std::string v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v3_HasQuantities, std::string v4_Discrimination, boost::optional< std::string > v5_Quality, boost::optional< std::string > v6_Usage); @@ -15311,13 +13649,7 @@ public: /// IFC2x Edition 3 CHANGE  The data type has been changed from STRING to BINARY. std::vector< boost::dynamic_bitset<> > /*[1:?]*/ Pixel() const; void setPixel(std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; case 7: return IfcUtil::Argument_AGGREGATE_OF_BINARY; } return IfcSurfaceTexture::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcInteger; case 5: return Type::IfcInteger; case 6: return Type::IfcInteger; case 7: return Type::UNDEFINED; } return IfcSurfaceTexture::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "Width"; case 5: return "Height"; case 6: return "ColourComponents"; case 7: return "Pixel"; } return IfcSurfaceTexture::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPixelTexture (IfcAbstractEntity* e); IfcPixelTexture (bool v1_RepeatS, bool v2_RepeatT, IfcSurfaceTextureEnum::IfcSurfaceTextureEnum v3_TextureType, IfcCartesianTransformationOperator2D* v4_TextureTransform, int v5_Width, int v6_Height, int v7_ColourComponents, std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v8_Pixel); @@ -15337,13 +13669,7 @@ public: /// The geometric position of a reference point, such as the center of a circle, of the item to be located. IfcCartesianPoint* Location() const; void setLocation(IfcCartesianPoint* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCartesianPoint; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Location"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPlacement (IfcAbstractEntity* e); IfcPlacement (IfcCartesianPoint* v1_Location); @@ -15362,13 +13688,7 @@ public: /// The extent in the direction of the y-axis. double SizeInY() const; void setSizeInY(double v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_DOUBLE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLengthMeasure; case 1: return Type::IfcLengthMeasure; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SizeInX"; case 1: return "SizeInY"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPlanarExtent (IfcAbstractEntity* e); IfcPlanarExtent (double v1_SizeInX, double v2_SizeInY); @@ -15381,13 +13701,7 @@ public: /// HISTORY: New entity in IFC Release 1.5 class IfcPoint : public IfcGeometricRepresentationItem { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPoint (IfcAbstractEntity* e); IfcPoint (); @@ -15410,13 +13724,7 @@ public: /// The parameter value of the point location. double PointParameter() const; void setPointParameter(double v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_DOUBLE; } return IfcPoint::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCurve; case 1: return Type::IfcParameterValue; } return IfcPoint::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BasisCurve"; case 1: return "PointParameter"; } return IfcPoint::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPointOnCurve (IfcAbstractEntity* e); IfcPointOnCurve (IfcCurve* v1_BasisCurve, double v2_PointParameter); @@ -15442,13 +13750,7 @@ public: /// The second parameter value of the point location. double PointParameterV() const; void setPointParameterV(double v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; } return IfcPoint::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcSurface; case 1: return Type::IfcParameterValue; case 2: return Type::IfcParameterValue; } return IfcPoint::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BasisSurface"; case 1: return "PointParameterU"; case 2: return "PointParameterV"; } return IfcPoint::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPointOnSurface (IfcAbstractEntity* e); IfcPointOnSurface (IfcSurface* v1_BasisSurface, double v2_PointParameterU, double v3_PointParameterV); @@ -15498,13 +13800,7 @@ public: /// List of points defining the loop. There are no repeated points in the list. IfcTemplatedEntityList< IfcCartesianPoint >::ptr Polygon() const; void setPolygon(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcLoop::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCartesianPoint; } return IfcLoop::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Polygon"; } return IfcLoop::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPolyLoop (IfcAbstractEntity* e); IfcPolyLoop (IfcTemplatedEntityList< IfcCartesianPoint >::ptr v1_Polygon); @@ -15576,13 +13872,7 @@ public: /// IFC2x Edition 3 CHANGE  The attribute type has been changed from IfcPolyline to its supertype IfcBoundedCurve with upward compatibility for file based exchange. IfcBoundedCurve* PolygonalBoundary() const; void setPolygonalBoundary(IfcBoundedCurve* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcHalfSpaceSolid::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcAxis2Placement3D; case 3: return Type::IfcBoundedCurve; } return IfcHalfSpaceSolid::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Position"; case 3: return "PolygonalBoundary"; } return IfcHalfSpaceSolid::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPolygonalBoundedHalfSpace (IfcAbstractEntity* e); IfcPolygonalBoundedHalfSpace (IfcSurface* v1_BaseSurface, bool v2_AgreementFlag, IfcAxis2Placement3D* v3_Position, IfcBoundedCurve* v4_PolygonalBoundary); @@ -15595,13 +13885,7 @@ public: /// HISTORY  New entity in IFC2x2. class IfcPreDefinedColour : public IfcPreDefinedItem { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPreDefinedItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPreDefinedItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPreDefinedItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPreDefinedColour (IfcAbstractEntity* e); IfcPreDefinedColour (std::string v1_Name); @@ -15616,13 +13900,7 @@ public: /// HISTORY: New entity in IFC2x2. class IfcPreDefinedCurveFont : public IfcPreDefinedItem { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPreDefinedItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPreDefinedItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPreDefinedItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPreDefinedCurveFont (IfcAbstractEntity* e); IfcPreDefinedCurveFont (std::string v1_Name); @@ -15631,13 +13909,7 @@ public: class IfcPreDefinedDimensionSymbol : public IfcPreDefinedSymbol { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPreDefinedSymbol::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPreDefinedSymbol::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPreDefinedSymbol::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPreDefinedDimensionSymbol (IfcAbstractEntity* e); IfcPreDefinedDimensionSymbol (std::string v1_Name); @@ -15646,13 +13918,7 @@ public: class IfcPreDefinedPointMarkerSymbol : public IfcPreDefinedSymbol { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPreDefinedSymbol::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPreDefinedSymbol::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPreDefinedSymbol::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPreDefinedPointMarkerSymbol (IfcAbstractEntity* e); IfcPreDefinedPointMarkerSymbol (std::string v1_Name); @@ -15672,15 +13938,9 @@ public: /// HISTORY  New Entity in IFC Release 1.5 class IfcProductDefinitionShape : public IfcProductRepresentation { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcProductRepresentation::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcProductRepresentation::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcProductRepresentation::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcProduct >::ptr ShapeOfProduct() const; // INVERSE IfcProduct::Representation + IfcTemplatedEntityList< IfcProduct >::ptr ShapeOfProduct() const; // INVERSE IfcProduct::Representation IfcTemplatedEntityList< IfcShapeAspect >::ptr HasShapeAspects() const; // INVERSE IfcShapeAspect::PartOfProductDefinitionShape - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProductDefinitionShape (IfcAbstractEntity* e); IfcProductDefinitionShape (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcRepresentation >::ptr v3_Representations); @@ -15807,13 +14067,7 @@ public: /// Unit for the upper and lower bound values, if not given, the default value for the measure type is used as defined by the global unit assignment at IfcProject.UnitInContext. The applicable unit is then selected by the underlying TYPE of the UpperBoundValue, LowerBoundValue, and SetPointValue) IfcUnit* Unit() const; void setUnit(IfcUnit* v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSimpleProperty::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcValue; case 3: return Type::IfcValue; case 4: return Type::IfcUnit; } return IfcSimpleProperty::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "UpperBoundValue"; case 3: return "LowerBoundValue"; case 4: return "Unit"; } return IfcSimpleProperty::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyBoundedValue (IfcAbstractEntity* e); IfcPropertyBoundedValue (std::string v1_Name, boost::optional< std::string > v2_Description, IfcValue* v3_UpperBoundValue, IfcValue* v4_LowerBoundValue, IfcUnit* v5_Unit); @@ -15871,14 +14125,8 @@ public: /// IfcPropertyTemplateDefinition for details. class IfcPropertyDefinition : public IfcRoot { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRoot::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRoot::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRoot::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssociates >::ptr HasAssociations() const; // INVERSE IfcRelAssociates::RelatedObjects - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelAssociates >::ptr HasAssociations() const; // INVERSE IfcRelAssociates::RelatedObjects + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyDefinition (IfcAbstractEntity* e); IfcPropertyDefinition (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -15973,13 +14221,7 @@ public: /// Enumeration from which a enumeration value has been selected. The referenced enumeration also establishes the unit of the enumeration value. IfcPropertyEnumeration* EnumerationReference() const; void setEnumerationReference(IfcPropertyEnumeration* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSimpleProperty::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcValue; case 3: return Type::IfcPropertyEnumeration; } return IfcSimpleProperty::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "EnumerationValues"; case 3: return "EnumerationReference"; } return IfcSimpleProperty::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyEnumeratedValue (IfcAbstractEntity* e); IfcPropertyEnumeratedValue (std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_EnumerationValues, IfcPropertyEnumeration* v4_EnumerationReference); @@ -16062,13 +14304,7 @@ public: /// Unit for the list values, if not given, the default value for the measure type (given by the TYPE of nominal value) is used as defined by the global unit assignment at IfcProject. IfcUnit* Unit() const; void setUnit(IfcUnit* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSimpleProperty::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcValue; case 3: return Type::IfcUnit; } return IfcSimpleProperty::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "ListValues"; case 3: return "Unit"; } return IfcSimpleProperty::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyListValue (IfcAbstractEntity* e); IfcPropertyListValue (std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_ListValues, IfcUnit* v4_Unit); @@ -16101,13 +14337,7 @@ public: /// IFC2x4 CHANGE  The attribute has been made optional with upward compatibility for file based exchange. IfcObjectReferenceSelect* PropertyReference() const; void setPropertyReference(IfcObjectReferenceSelect* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSimpleProperty::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcLabel; case 3: return Type::IfcObjectReferenceSelect; } return IfcSimpleProperty::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "UsageName"; case 3: return "PropertyReference"; } return IfcSimpleProperty::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyReferenceValue (IfcAbstractEntity* e); IfcPropertyReferenceValue (std::string v1_Name, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UsageName, IfcObjectReferenceSelect* v4_PropertyReference); @@ -16157,15 +14387,9 @@ public: /// NOTE  Properties assigned to object occurrences may override properties assigned to the object type. See IfcRelDefinesByType for further information. class IfcPropertySetDefinition : public IfcPropertyDefinition { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPropertyDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPropertyDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPropertyDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelDefinesByProperties >::ptr PropertyDefinitionOf() const; // INVERSE IfcRelDefinesByProperties::RelatingPropertyDefinition + IfcTemplatedEntityList< IfcRelDefinesByProperties >::ptr PropertyDefinitionOf() const; // INVERSE IfcRelDefinesByProperties::RelatingPropertyDefinition IfcTemplatedEntityList< IfcTypeObject >::ptr DefinesType() const; // INVERSE IfcTypeObject::HasPropertySets - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertySetDefinition (IfcAbstractEntity* e); IfcPropertySetDefinition (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -16231,13 +14455,7 @@ public: /// Unit for the nominal value, if not given, the default value for the measure type (given by the TYPE of nominal value) is used as defined by the global unit assignment at IfcProject. IfcUnit* Unit() const; void setUnit(IfcUnit* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSimpleProperty::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcValue; case 3: return Type::IfcUnit; } return IfcSimpleProperty::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "NominalValue"; case 3: return "Unit"; } return IfcSimpleProperty::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertySingleValue (IfcAbstractEntity* e); IfcPropertySingleValue (std::string v1_Name, boost::optional< std::string > v2_Description, IfcValue* v3_NominalValue, IfcUnit* v4_Unit); @@ -16416,13 +14634,7 @@ public: /// Unit for the defined values, if not given, the default value for the measure type (given by the TYPE of the defined values) is used as defined by the global unit assignment at IfcProject. IfcUnit* DefinedUnit() const; void setDefinedUnit(IfcUnit* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSimpleProperty::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcValue; case 3: return Type::IfcValue; case 4: return Type::IfcText; case 5: return Type::IfcUnit; case 6: return Type::IfcUnit; } return IfcSimpleProperty::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "DefiningValues"; case 3: return "DefinedValues"; case 4: return "Expression"; case 5: return "DefiningUnit"; case 6: return "DefinedUnit"; } return IfcSimpleProperty::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyTableValue (IfcAbstractEntity* e); IfcPropertyTableValue (std::string v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_DefiningValues, IfcEntityList::ptr v4_DefinedValues, boost::optional< std::string > v5_Expression, IfcUnit* v6_DefiningUnit, IfcUnit* v7_DefinedUnit); @@ -16470,13 +14682,7 @@ public: /// The extent of the rectangle in the direction of the y-axis. double YDim() const; void setYDim(double v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "XDim"; case 4: return "YDim"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRectangleProfileDef (IfcAbstractEntity* e); IfcRectangleProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim); @@ -16495,13 +14701,7 @@ public: /// The collection of time series values. IfcTemplatedEntityList< IfcTimeSeriesValue >::ptr Values() const; void setValues(IfcTemplatedEntityList< IfcTimeSeriesValue >::ptr v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcTimeSeries::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcTimeMeasure; case 9: return Type::IfcTimeSeriesValue; } return IfcTimeSeries::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "TimeStep"; case 9: return "Values"; } return IfcTimeSeries::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRegularTimeSeries (IfcAbstractEntity* e); IfcRegularTimeSeries (std::string v1_Name, boost::optional< std::string > v2_Description, IfcDateTimeSelect* v3_StartTime, IfcDateTimeSelect* v4_EndTime, IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v5_TimeSeriesDataType, IfcDataOriginEnum::IfcDataOriginEnum v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, IfcUnit* v8_Unit, double v9_TimeStep, IfcTemplatedEntityList< IfcTimeSeriesValue >::ptr v10_Values); @@ -16543,13 +14743,7 @@ public: /// The list of section reinforcement properties attached to the reinforcement definition properties. IfcTemplatedEntityList< IfcSectionReinforcementProperties >::ptr ReinforcementSectionDefinitions() const; void setReinforcementSectionDefinitions(IfcTemplatedEntityList< IfcSectionReinforcementProperties >::ptr v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcLabel; case 5: return Type::IfcSectionReinforcementProperties; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "DefinitionType"; case 5: return "ReinforcementSectionDefinitions"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcReinforcementDefinitionProperties (IfcAbstractEntity* e); IfcReinforcementDefinitionProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_DefinitionType, IfcTemplatedEntityList< IfcSectionReinforcementProperties >::ptr v6_ReinforcementSectionDefinitions); @@ -16565,13 +14759,7 @@ public: /// HISTORY: New entity in IFC Release 1.0. class IfcRelationship : public IfcRoot { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRoot::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRoot::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRoot::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelationship (IfcAbstractEntity* e); IfcRelationship (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -16619,13 +14807,7 @@ public: /// Radius of the circular arcs by which all four corners of the rectangle are equally rounded. double RoundingRadius() const; void setRoundingRadius(double v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_DOUBLE; } return IfcRectangleProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcPositiveLengthMeasure; } return IfcRectangleProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RoundingRadius"; } return IfcRectangleProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRoundedRectangleProfileDef (IfcAbstractEntity* e); IfcRoundedRectangleProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim, double v6_RoundingRadius); @@ -16695,13 +14877,7 @@ public: /// Position coordinate systems for the cross sections that form the sectioned spine. The profiles defining the cross sections are positioned within the xy plane of the corresponding position coordinate system. IfcTemplatedEntityList< IfcAxis2Placement3D >::ptr CrossSectionPositions() const; void setCrossSectionPositions(IfcTemplatedEntityList< IfcAxis2Placement3D >::ptr v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCompositeCurve; case 1: return Type::IfcProfileDef; case 2: return Type::IfcAxis2Placement3D; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SpineCurve"; case 1: return "CrossSections"; case 2: return "CrossSectionPositions"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSectionedSpine (IfcAbstractEntity* e); IfcSectionedSpine (IfcCompositeCurve* v1_SpineCurve, IfcTemplatedEntityList< IfcProfileDef >::ptr v2_CrossSections, IfcTemplatedEntityList< IfcAxis2Placement3D >::ptr v3_CrossSectionPositions); @@ -16722,13 +14898,7 @@ public: bool hasLowerValue() const; IfcMeasureValue* LowerValue() const; void setLowerValue(IfcMeasureValue* v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcServiceLifeFactorTypeEnum; case 5: return Type::IfcMeasureValue; case 6: return Type::IfcMeasureValue; case 7: return Type::IfcMeasureValue; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "PredefinedType"; case 5: return "UpperValue"; case 6: return "MostUsedValue"; case 7: return "LowerValue"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcServiceLifeFactor (IfcAbstractEntity* e); IfcServiceLifeFactor (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum v5_PredefinedType, IfcMeasureValue* v6_UpperValue, IfcMeasureValue* v7_MostUsedValue, IfcMeasureValue* v8_LowerValue); @@ -16750,13 +14920,7 @@ class IfcShellBasedSurfaceModel : public IfcGeometricRepresentationItem { public: IfcEntityList::ptr SbsmBoundary() const; void setSbsmBoundary(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcShell; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SbsmBoundary"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcShellBasedSurfaceModel (IfcAbstractEntity* e); IfcShellBasedSurfaceModel (IfcEntityList::ptr v1_SbsmBoundary); @@ -16788,13 +14952,7 @@ public: /// Slippage in z-direction of the coordinate system defined by the instance which uses this resource object. double SlippageZ() const; void setSlippageZ(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcStructuralConnectionCondition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcLengthMeasure; case 2: return Type::IfcLengthMeasure; case 3: return Type::IfcLengthMeasure; } return IfcStructuralConnectionCondition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "SlippageX"; case 2: return "SlippageY"; case 3: return "SlippageZ"; } return IfcStructuralConnectionCondition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSlippageConnectionCondition (IfcAbstractEntity* e); IfcSlippageConnectionCondition (boost::optional< std::string > v1_Name, boost::optional< double > v2_SlippageX, boost::optional< double > v3_SlippageY, boost::optional< double > v4_SlippageZ); @@ -16807,13 +14965,7 @@ public: /// HISTORY: New entity in IFC Release 1.5 class IfcSolidModel : public IfcGeometricRepresentationItem { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSolidModel (IfcAbstractEntity* e); IfcSolidModel (); @@ -16830,13 +14982,7 @@ public: void setSoundScale(IfcSoundScaleEnum::IfcSoundScaleEnum v); IfcTemplatedEntityList< IfcSoundValue >::ptr SoundValues() const; void setSoundValues(IfcTemplatedEntityList< IfcSoundValue >::ptr v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_BOOL; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcBoolean; case 5: return Type::IfcSoundScaleEnum; case 6: return Type::IfcSoundValue; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "IsAttenuating"; case 5: return "SoundScale"; case 6: return "SoundValues"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSoundProperties (IfcAbstractEntity* e); IfcSoundProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, bool v5_IsAttenuating, boost::optional< IfcSoundScaleEnum::IfcSoundScaleEnum > v6_SoundScale, IfcTemplatedEntityList< IfcSoundValue >::ptr v7_SoundValues); @@ -16855,13 +15001,7 @@ public: bool hasSoundLevelSingleValue() const; IfcDerivedMeasureValue* SoundLevelSingleValue() const; void setSoundLevelSingleValue(IfcDerivedMeasureValue* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcTimeSeries; case 5: return Type::IfcFrequencyMeasure; case 6: return Type::IfcDerivedMeasureValue; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "SoundLevelTimeSeries"; case 5: return "Frequency"; case 6: return "SoundLevelSingleValue"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSoundValue (IfcAbstractEntity* e); IfcSoundValue (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTimeSeries* v5_SoundLevelTimeSeries, double v6_Frequency, IfcDerivedMeasureValue* v7_SoundLevelSingleValue); @@ -16902,13 +15042,7 @@ public: void setUserDefinedPropertySource(std::string v); IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum ThermalLoadType() const; void setThermalLoadType(IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum v); - virtual unsigned int getArgumentCount() const { return 14; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_ENUMERATION; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_ENTITY_INSTANCE; case 11: return IfcUtil::Argument_STRING; case 12: return IfcUtil::Argument_STRING; case 13: return IfcUtil::Argument_ENUMERATION; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPositiveRatioMeasure; case 5: return Type::IfcThermalLoadSourceEnum; case 6: return Type::IfcPropertySourceEnum; case 7: return Type::IfcText; case 8: return Type::IfcPowerMeasure; case 9: return Type::IfcPowerMeasure; case 10: return Type::IfcTimeSeries; case 11: return Type::IfcLabel; case 12: return Type::IfcLabel; case 13: return Type::IfcThermalLoadTypeEnum; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "ApplicableValueRatio"; case 5: return "ThermalLoadSource"; case 6: return "PropertySource"; case 7: return "SourceDescription"; case 8: return "MaximumValue"; case 9: return "MinimumValue"; case 10: return "ThermalLoadTimeSeriesValues"; case 11: return "UserDefinedThermalLoadSource"; case 12: return "UserDefinedPropertySource"; case 13: return "ThermalLoadType"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSpaceThermalLoadProperties (IfcAbstractEntity* e); IfcSpaceThermalLoadProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_ApplicableValueRatio, IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum v6_ThermalLoadSource, IfcPropertySourceEnum::IfcPropertySourceEnum v7_PropertySource, boost::optional< std::string > v8_SourceDescription, double v9_MaximumValue, boost::optional< double > v10_MinimumValue, IfcTimeSeries* v11_ThermalLoadTimeSeriesValues, boost::optional< std::string > v12_UserDefinedThermalLoadSource, boost::optional< std::string > v13_UserDefinedPropertySource, IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum v14_ThermalLoadType); @@ -16951,13 +15085,7 @@ public: /// Linear moment about the z-axis. double LinearMomentZ() const; void setLinearMomentZ(double v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; } return IfcStructuralLoadStatic::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcLinearForceMeasure; case 2: return Type::IfcLinearForceMeasure; case 3: return Type::IfcLinearForceMeasure; case 4: return Type::IfcLinearMomentMeasure; case 5: return Type::IfcLinearMomentMeasure; case 6: return Type::IfcLinearMomentMeasure; } return IfcStructuralLoadStatic::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "LinearForceX"; case 2: return "LinearForceY"; case 3: return "LinearForceZ"; case 4: return "LinearMomentX"; case 5: return "LinearMomentY"; case 6: return "LinearMomentZ"; } return IfcStructuralLoadStatic::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLoadLinearForce (IfcAbstractEntity* e); IfcStructuralLoadLinearForce (boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearForceX, boost::optional< double > v3_LinearForceY, boost::optional< double > v4_LinearForceZ, boost::optional< double > v5_LinearMomentX, boost::optional< double > v6_LinearMomentY, boost::optional< double > v7_LinearMomentZ); @@ -16985,13 +15113,7 @@ public: /// Planar force value in z-direction. double PlanarForceZ() const; void setPlanarForceZ(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcStructuralLoadStatic::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcPlanarForceMeasure; case 2: return Type::IfcPlanarForceMeasure; case 3: return Type::IfcPlanarForceMeasure; } return IfcStructuralLoadStatic::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "PlanarForceX"; case 2: return "PlanarForceY"; case 3: return "PlanarForceZ"; } return IfcStructuralLoadStatic::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLoadPlanarForce (IfcAbstractEntity* e); IfcStructuralLoadPlanarForce (boost::optional< std::string > v1_Name, boost::optional< double > v2_PlanarForceX, boost::optional< double > v3_PlanarForceY, boost::optional< double > v4_PlanarForceZ); @@ -17034,13 +15156,7 @@ public: /// Rotation about the z-axis. double RotationalDisplacementRZ() const; void setRotationalDisplacementRZ(double v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; } return IfcStructuralLoadStatic::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcLengthMeasure; case 2: return Type::IfcLengthMeasure; case 3: return Type::IfcLengthMeasure; case 4: return Type::IfcPlaneAngleMeasure; case 5: return Type::IfcPlaneAngleMeasure; case 6: return Type::IfcPlaneAngleMeasure; } return IfcStructuralLoadStatic::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "DisplacementX"; case 2: return "DisplacementY"; case 3: return "DisplacementZ"; case 4: return "RotationalDisplacementRX"; case 5: return "RotationalDisplacementRY"; case 6: return "RotationalDisplacementRZ"; } return IfcStructuralLoadStatic::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLoadSingleDisplacement (IfcAbstractEntity* e); IfcStructuralLoadSingleDisplacement (boost::optional< std::string > v1_Name, boost::optional< double > v2_DisplacementX, boost::optional< double > v3_DisplacementY, boost::optional< double > v4_DisplacementZ, boost::optional< double > v5_RotationalDisplacementRX, boost::optional< double > v6_RotationalDisplacementRY, boost::optional< double > v7_RotationalDisplacementRZ); @@ -17056,13 +15172,7 @@ public: /// The distortion curvature (warping, i.e. a cross-sectional deplanation) given to the displacement load. double Distortion() const; void setDistortion(double v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_DOUBLE; } return IfcStructuralLoadSingleDisplacement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcCurvatureMeasure; } return IfcStructuralLoadSingleDisplacement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "Distortion"; } return IfcStructuralLoadSingleDisplacement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLoadSingleDisplacementDistortion (IfcAbstractEntity* e); IfcStructuralLoadSingleDisplacementDistortion (boost::optional< std::string > v1_Name, boost::optional< double > v2_DisplacementX, boost::optional< double > v3_DisplacementY, boost::optional< double > v4_DisplacementZ, boost::optional< double > v5_RotationalDisplacementRX, boost::optional< double > v6_RotationalDisplacementRY, boost::optional< double > v7_RotationalDisplacementRZ, boost::optional< double > v8_Distortion); @@ -17106,13 +15216,7 @@ public: /// Moment about the z-axis. double MomentZ() const; void setMomentZ(double v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; } return IfcStructuralLoadStatic::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcForceMeasure; case 2: return Type::IfcForceMeasure; case 3: return Type::IfcForceMeasure; case 4: return Type::IfcTorqueMeasure; case 5: return Type::IfcTorqueMeasure; case 6: return Type::IfcTorqueMeasure; } return IfcStructuralLoadStatic::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "ForceX"; case 2: return "ForceY"; case 3: return "ForceZ"; case 4: return "MomentX"; case 5: return "MomentY"; case 6: return "MomentZ"; } return IfcStructuralLoadStatic::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLoadSingleForce (IfcAbstractEntity* e); IfcStructuralLoadSingleForce (boost::optional< std::string > v1_Name, boost::optional< double > v2_ForceX, boost::optional< double > v3_ForceY, boost::optional< double > v4_ForceZ, boost::optional< double > v5_MomentX, boost::optional< double > v6_MomentY, boost::optional< double > v7_MomentZ); @@ -17133,13 +15237,7 @@ public: /// The warping moment at the point load. double WarpingMoment() const; void setWarpingMoment(double v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_DOUBLE; } return IfcStructuralLoadSingleForce::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcWarpingMomentMeasure; } return IfcStructuralLoadSingleForce::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "WarpingMoment"; } return IfcStructuralLoadSingleForce::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLoadSingleForceWarping (IfcAbstractEntity* e); IfcStructuralLoadSingleForceWarping (boost::optional< std::string > v1_Name, boost::optional< double > v2_ForceX, boost::optional< double > v3_ForceY, boost::optional< double > v4_ForceZ, boost::optional< double > v5_MomentX, boost::optional< double > v6_MomentY, boost::optional< double > v7_MomentZ, boost::optional< double > v8_WarpingMoment); @@ -17212,13 +15310,7 @@ public: bool hasCentreOfGravityInY() const; double CentreOfGravityInY() const; void setCentreOfGravityInY(double v); - virtual unsigned int getArgumentCount() const { return 23; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_DOUBLE; case 13: return IfcUtil::Argument_DOUBLE; case 14: return IfcUtil::Argument_DOUBLE; case 15: return IfcUtil::Argument_DOUBLE; case 16: return IfcUtil::Argument_DOUBLE; case 17: return IfcUtil::Argument_DOUBLE; case 18: return IfcUtil::Argument_DOUBLE; case 19: return IfcUtil::Argument_DOUBLE; case 20: return IfcUtil::Argument_DOUBLE; case 21: return IfcUtil::Argument_DOUBLE; case 22: return IfcUtil::Argument_DOUBLE; } return IfcGeneralProfileProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcMomentOfInertiaMeasure; case 8: return Type::IfcMomentOfInertiaMeasure; case 9: return Type::IfcMomentOfInertiaMeasure; case 10: return Type::IfcMomentOfInertiaMeasure; case 11: return Type::IfcWarpingConstantMeasure; case 12: return Type::IfcLengthMeasure; case 13: return Type::IfcLengthMeasure; case 14: return Type::IfcAreaMeasure; case 15: return Type::IfcAreaMeasure; case 16: return Type::IfcSectionModulusMeasure; case 17: return Type::IfcSectionModulusMeasure; case 18: return Type::IfcSectionModulusMeasure; case 19: return Type::IfcSectionModulusMeasure; case 20: return Type::IfcSectionModulusMeasure; case 21: return Type::IfcLengthMeasure; case 22: return Type::IfcLengthMeasure; } return IfcGeneralProfileProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "TorsionalConstantX"; case 8: return "MomentOfInertiaYZ"; case 9: return "MomentOfInertiaY"; case 10: return "MomentOfInertiaZ"; case 11: return "WarpingConstant"; case 12: return "ShearCentreZ"; case 13: return "ShearCentreY"; case 14: return "ShearDeformationAreaZ"; case 15: return "ShearDeformationAreaY"; case 16: return "MaximumSectionModulusY"; case 17: return "MinimumSectionModulusY"; case 18: return "MaximumSectionModulusZ"; case 19: return "MinimumSectionModulusZ"; case 20: return "TorsionalSectionModulus"; case 21: return "CentreOfGravityInX"; case 22: return "CentreOfGravityInY"; } return IfcGeneralProfileProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralProfileProperties (IfcAbstractEntity* e); IfcStructuralProfileProperties (boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea, boost::optional< double > v8_TorsionalConstantX, boost::optional< double > v9_MomentOfInertiaYZ, boost::optional< double > v10_MomentOfInertiaY, boost::optional< double > v11_MomentOfInertiaZ, boost::optional< double > v12_WarpingConstant, boost::optional< double > v13_ShearCentreZ, boost::optional< double > v14_ShearCentreY, boost::optional< double > v15_ShearDeformationAreaZ, boost::optional< double > v16_ShearDeformationAreaY, boost::optional< double > v17_MaximumSectionModulusY, boost::optional< double > v18_MinimumSectionModulusY, boost::optional< double > v19_MaximumSectionModulusZ, boost::optional< double > v20_MinimumSectionModulusZ, boost::optional< double > v21_TorsionalSectionModulus, boost::optional< double > v22_CentreOfGravityInX, boost::optional< double > v23_CentreOfGravityInY); @@ -17243,13 +15335,7 @@ public: bool hasPlasticShapeFactorZ() const; double PlasticShapeFactorZ() const; void setPlasticShapeFactorZ(double v); - virtual unsigned int getArgumentCount() const { return 27; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 23: return IfcUtil::Argument_DOUBLE; case 24: return IfcUtil::Argument_DOUBLE; case 25: return IfcUtil::Argument_DOUBLE; case 26: return IfcUtil::Argument_DOUBLE; } return IfcStructuralProfileProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 23: return Type::IfcAreaMeasure; case 24: return Type::IfcAreaMeasure; case 25: return Type::IfcPositiveRatioMeasure; case 26: return Type::IfcPositiveRatioMeasure; } return IfcStructuralProfileProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 23: return "ShearAreaZ"; case 24: return "ShearAreaY"; case 25: return "PlasticShapeFactorY"; case 26: return "PlasticShapeFactorZ"; } return IfcStructuralProfileProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralSteelProfileProperties (IfcAbstractEntity* e); IfcStructuralSteelProfileProperties (boost::optional< std::string > v1_ProfileName, IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea, boost::optional< double > v8_TorsionalConstantX, boost::optional< double > v9_MomentOfInertiaYZ, boost::optional< double > v10_MomentOfInertiaY, boost::optional< double > v11_MomentOfInertiaZ, boost::optional< double > v12_WarpingConstant, boost::optional< double > v13_ShearCentreZ, boost::optional< double > v14_ShearCentreY, boost::optional< double > v15_ShearDeformationAreaZ, boost::optional< double > v16_ShearDeformationAreaY, boost::optional< double > v17_MaximumSectionModulusY, boost::optional< double > v18_MinimumSectionModulusY, boost::optional< double > v19_MaximumSectionModulusZ, boost::optional< double > v20_MinimumSectionModulusZ, boost::optional< double > v21_TorsionalSectionModulus, boost::optional< double > v22_CentreOfGravityInX, boost::optional< double > v23_CentreOfGravityInY, boost::optional< double > v24_ShearAreaZ, boost::optional< double > v25_ShearAreaY, boost::optional< double > v26_PlasticShapeFactorY, boost::optional< double > v27_PlasticShapeFactorZ); @@ -17270,13 +15356,7 @@ public: /// The Edge, or Subedge, which contains the Subedge. IfcEdge* ParentEdge() const; void setParentEdge(IfcEdge* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcEdge::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcEdge; } return IfcEdge::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "ParentEdge"; } return IfcEdge::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSubedge (IfcAbstractEntity* e); IfcSubedge (IfcVertex* v1_EdgeStart, IfcVertex* v2_EdgeEnd, IfcEdge* v3_ParentEdge); @@ -17294,13 +15374,7 @@ public: /// A surface is arcwise connected. class IfcSurface : public IfcGeometricRepresentationItem { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurface (IfcAbstractEntity* e); IfcSurface (); @@ -17402,13 +15476,7 @@ public: /// Identifies the predefined types of reflectance method from which the method required may be set. IfcReflectanceMethodEnum::IfcReflectanceMethodEnum ReflectanceMethod() const; void setReflectanceMethod(IfcReflectanceMethodEnum::IfcReflectanceMethodEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENUMERATION; } return IfcSurfaceStyleShading::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcNormalisedRatioMeasure; case 2: return Type::IfcColourOrFactor; case 3: return Type::IfcColourOrFactor; case 4: return Type::IfcColourOrFactor; case 5: return Type::IfcColourOrFactor; case 6: return Type::IfcColourOrFactor; case 7: return Type::IfcSpecularHighlightSelect; case 8: return Type::IfcReflectanceMethodEnum; } return IfcSurfaceStyleShading::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Transparency"; case 2: return "DiffuseColour"; case 3: return "TransmissionColour"; case 4: return "DiffuseTransmissionColour"; case 5: return "ReflectionColour"; case 6: return "SpecularColour"; case 7: return "SpecularHighlight"; case 8: return "ReflectanceMethod"; } return IfcSurfaceStyleShading::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceStyleRendering (IfcAbstractEntity* e); IfcSurfaceStyleRendering (IfcColourRgb* v1_SurfaceColour, boost::optional< double > v2_Transparency, IfcColourOrFactor* v3_DiffuseColour, IfcColourOrFactor* v4_TransmissionColour, IfcColourOrFactor* v5_DiffuseTransmissionColour, IfcColourOrFactor* v6_ReflectionColour, IfcColourOrFactor* v7_SpecularColour, IfcSpecularHighlightSelect* v8_SpecularHighlight, IfcReflectanceMethodEnum::IfcReflectanceMethodEnum v9_ReflectanceMethod); @@ -17440,13 +15508,7 @@ public: /// Position coordinate system for the swept area, provided by a profile definition within the XY plane of the Position. IfcAxis2Placement3D* Position() const; void setPosition(IfcAxis2Placement3D* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSolidModel::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcProfileDef; case 1: return Type::IfcAxis2Placement3D; } return IfcSolidModel::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SweptArea"; case 1: return "Position"; } return IfcSolidModel::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSweptAreaSolid (IfcAbstractEntity* e); IfcSweptAreaSolid (IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position); @@ -17528,13 +15590,7 @@ public: /// IFC2x4 CHANGE  The attribute has been changed to OPTIONAL with upward compatibility for file-based exchange. double EndParam() const; void setEndParam(double v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; } return IfcSolidModel::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCurve; case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcPositiveLengthMeasure; case 3: return Type::IfcParameterValue; case 4: return Type::IfcParameterValue; } return IfcSolidModel::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Directrix"; case 1: return "Radius"; case 2: return "InnerRadius"; case 3: return "StartParam"; case 4: return "EndParam"; } return IfcSolidModel::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSweptDiskSolid (IfcAbstractEntity* e); IfcSweptDiskSolid (IfcCurve* v1_Directrix, double v2_Radius, boost::optional< double > v3_InnerRadius, double v4_StartParam, double v5_EndParam); @@ -17553,13 +15609,7 @@ public: /// Position coordinate system for the placement of the profile within the xy plane of the axis placement. IfcAxis2Placement3D* Position() const; void setPosition(IfcAxis2Placement3D* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSurface::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcProfileDef; case 1: return Type::IfcAxis2Placement3D; } return IfcSurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SweptCurve"; case 1: return "Position"; } return IfcSurface::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSweptSurface (IfcAbstractEntity* e); IfcSweptSurface (IfcProfileDef* v1_SweptCurve, IfcAxis2Placement3D* v2_Position); @@ -17636,13 +15686,7 @@ public: bool hasCentreOfGravityInY() const; double CentreOfGravityInY() const; void setCentreOfGravityInY(double v); - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcPositiveLengthMeasure; case 9: return Type::IfcPositiveLengthMeasure; case 10: return Type::IfcPlaneAngleMeasure; case 11: return Type::IfcPlaneAngleMeasure; case 12: return Type::IfcPositiveLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "Depth"; case 4: return "FlangeWidth"; case 5: return "WebThickness"; case 6: return "FlangeThickness"; case 7: return "FilletRadius"; case 8: return "FlangeEdgeRadius"; case 9: return "WebEdgeRadius"; case 10: return "WebSlope"; case 11: return "FlangeSlope"; case 12: return "CentreOfGravityInY"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTShapeProfileDef (IfcAbstractEntity* e); IfcTShapeProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_FlangeEdgeRadius, boost::optional< double > v10_WebEdgeRadius, boost::optional< double > v11_WebSlope, boost::optional< double > v12_FlangeSlope, boost::optional< double > v13_CentreOfGravityInY); @@ -17653,13 +15697,7 @@ class IfcTerminatorSymbol : public IfcAnnotationSymbolOccurrence { public: IfcAnnotationCurveOccurrence* AnnotatedCurve() const; void setAnnotatedCurve(IfcAnnotationCurveOccurrence* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcAnnotationSymbolOccurrence::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcAnnotationCurveOccurrence; } return IfcAnnotationSymbolOccurrence::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "AnnotatedCurve"; } return IfcAnnotationSymbolOccurrence::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTerminatorSymbol (IfcAbstractEntity* e); IfcTerminatorSymbol (IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, IfcAnnotationCurveOccurrence* v4_AnnotatedCurve); @@ -17687,13 +15725,7 @@ public: /// The writing direction of the text literal. IfcTextPath::IfcTextPath Path() const; void setPath(IfcTextPath::IfcTextPath v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENUMERATION; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPresentableText; case 1: return Type::IfcAxis2Placement; case 2: return Type::IfcTextPath; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Literal"; case 1: return "Placement"; case 2: return "Path"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextLiteral (IfcAbstractEntity* e); IfcTextLiteral (std::string v1_Literal, IfcAxis2Placement* v2_Placement, IfcTextPath::IfcTextPath v3_Path); @@ -17716,13 +15748,7 @@ public: /// The alignment of the text literal relative to its position. std::string BoxAlignment() const; void setBoxAlignment(std::string v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; } return IfcTextLiteral::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPlanarExtent; case 4: return Type::IfcBoxAlignment; } return IfcTextLiteral::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "Extent"; case 4: return "BoxAlignment"; } return IfcTextLiteral::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextLiteralWithExtent (IfcAbstractEntity* e); IfcTextLiteralWithExtent (std::string v1_Literal, IfcAxis2Placement* v2_Placement, IfcTextPath::IfcTextPath v3_Path, IfcPlanarExtent* v4_Extent, std::string v5_BoxAlignment); @@ -17780,13 +15806,7 @@ public: /// Offset from the beginning of the top line to the bottom line, measured along the implicit x-axis. double TopXOffset() const; void setTopXOffset(double v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "BottomXDim"; case 4: return "TopXDim"; case 5: return "YDim"; case 6: return "TopXOffset"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTrapeziumProfileDef (IfcAbstractEntity* e); IfcTrapeziumProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_BottomXDim, double v5_TopXDim, double v6_YDim, double v7_TopXOffset); @@ -17805,13 +15825,7 @@ public: /// A vector which specifies the relative positioning of tiles in the second direction. IfcVector* SecondRepeatFactor() const; void setSecondRepeatFactor(IfcVector* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcOneDirectionRepeatFactor::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcVector; } return IfcOneDirectionRepeatFactor::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "SecondRepeatFactor"; } return IfcOneDirectionRepeatFactor::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTwoDirectionRepeatFactor (IfcAbstractEntity* e); IfcTwoDirectionRepeatFactor (IfcVector* v1_RepeatFactor, IfcVector* v2_SecondRepeatFactor); @@ -17868,14 +15882,8 @@ public: /// IFC2x3 CHANGE  The attribute aggregate type has been changed from LIST to SET. IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr HasPropertySets() const; void setHasPropertySets(IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcObjectDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcLabel; case 5: return Type::IfcPropertySetDefinition; } return IfcObjectDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "ApplicableOccurrence"; case 5: return "HasPropertySets"; } return IfcObjectDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelDefinesByType >::ptr ObjectTypeOf() const; // INVERSE IfcRelDefinesByType::RelatingType - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelDefinesByType >::ptr ObjectTypeOf() const; // INVERSE IfcRelDefinesByType::RelatingType + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTypeObject (IfcAbstractEntity* e); IfcTypeObject (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets); @@ -17959,13 +15967,7 @@ public: /// The tag (or label) identifier at the particular type of a product, e.g. the article number (like the EAN). It is the identifier at the specific level. std::string Tag() const; void setTag(std::string v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_STRING; } return IfcTypeObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcRepresentationMap; case 7: return Type::IfcLabel; } return IfcTypeObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "RepresentationMaps"; case 7: return "Tag"; } return IfcTypeObject::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTypeProduct (IfcAbstractEntity* e); IfcTypeProduct (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag); @@ -18032,13 +16034,7 @@ public: bool hasCentreOfGravityInX() const; double CentreOfGravityInX() const; void setCentreOfGravityInX(double v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcPositiveLengthMeasure; case 9: return Type::IfcPlaneAngleMeasure; case 10: return Type::IfcPositiveLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "Depth"; case 4: return "FlangeWidth"; case 5: return "WebThickness"; case 6: return "FlangeThickness"; case 7: return "FilletRadius"; case 8: return "EdgeRadius"; case 9: return "FlangeSlope"; case 10: return "CentreOfGravityInX"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcUShapeProfileDef (IfcAbstractEntity* e); IfcUShapeProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_EdgeRadius, boost::optional< double > v10_FlangeSlope, boost::optional< double > v11_CentreOfGravityInX); @@ -18059,13 +16055,7 @@ public: /// The magnitude of the vector. All vectors of Magnitude 0.0 are regarded as equal in value regardless of the orientation attribute. double Magnitude() const; void setMagnitude(double v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_DOUBLE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDirection; case 1: return Type::IfcLengthMeasure; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Orientation"; case 1: return "Magnitude"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcVector (IfcAbstractEntity* e); IfcVector (IfcDirection* v1_Orientation, double v2_Magnitude); @@ -18088,13 +16078,7 @@ public: /// The vertex which defines the entire loop. IfcVertex* LoopVertex() const; void setLoopVertex(IfcVertex* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcLoop::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcVertex; } return IfcLoop::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LoopVertex"; } return IfcLoop::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcVertexLoop (IfcAbstractEntity* e); IfcVertexLoop (IfcVertex* v1_LoopVertex); @@ -18247,13 +16231,7 @@ public: /// IFC2x4 CHANGE The attribute is deprecated and shall no longer be used, i.e. the value shall be NIL ($). IfcShapeAspect* ShapeAspectStyle() const; void setShapeAspectStyle(IfcShapeAspect* v); - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcNormalisedRatioMeasure; case 9: return Type::IfcNormalisedRatioMeasure; case 10: return Type::IfcNormalisedRatioMeasure; case 11: return Type::IfcNormalisedRatioMeasure; case 12: return Type::IfcShapeAspect; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "LiningDepth"; case 5: return "LiningThickness"; case 6: return "TransomThickness"; case 7: return "MullionThickness"; case 8: return "FirstTransomOffset"; case 9: return "SecondTransomOffset"; case 10: return "FirstMullionOffset"; case 11: return "SecondMullionOffset"; case 12: return "ShapeAspectStyle"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWindowLiningProperties (IfcAbstractEntity* e); IfcWindowLiningProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_LiningDepth, boost::optional< double > v6_LiningThickness, boost::optional< double > v7_TransomThickness, boost::optional< double > v8_MullionThickness, boost::optional< double > v9_FirstTransomOffset, boost::optional< double > v10_SecondTransomOffset, boost::optional< double > v11_FirstMullionOffset, boost::optional< double > v12_SecondMullionOffset, IfcShapeAspect* v13_ShapeAspectStyle); @@ -18329,13 +16307,7 @@ public: /// IFC2x4 CHANGE The attribute is deprecated and shall no longer be used, i.e. the value shall be NIL ($). IfcShapeAspect* ShapeAspectStyle() const; void setShapeAspectStyle(IfcShapeAspect* v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcWindowPanelOperationEnum; case 5: return Type::IfcWindowPanelPositionEnum; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcShapeAspect; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "OperationType"; case 5: return "PanelPosition"; case 6: return "FrameDepth"; case 7: return "FrameThickness"; case 8: return "ShapeAspectStyle"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWindowPanelProperties (IfcAbstractEntity* e); IfcWindowPanelProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum v5_OperationType, IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum v6_PanelPosition, boost::optional< double > v7_FrameDepth, boost::optional< double > v8_FrameThickness, IfcShapeAspect* v9_ShapeAspectStyle); @@ -18373,13 +16345,7 @@ public: /// The Boolean indicates, whether the attached ShapeStyle can be sized (using scale factor of transformation), or not (FALSE). If not, the ShapeStyle should be inserted by the IfcWindow (using IfcMappedItem) with the scale factor = 1. bool Sizeable() const; void setSizeable(bool v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_ENUMERATION; case 10: return IfcUtil::Argument_BOOL; case 11: return IfcUtil::Argument_BOOL; } return IfcTypeProduct::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcWindowStyleConstructionEnum; case 9: return Type::IfcWindowStyleOperationEnum; case 10: return Type::UNDEFINED; case 11: return Type::UNDEFINED; } return IfcTypeProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "ConstructionType"; case 9: return "OperationType"; case 10: return "ParameterTakesPrecedence"; case 11: return "Sizeable"; } return IfcTypeProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWindowStyle (IfcAbstractEntity* e); IfcWindowStyle (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum v9_ConstructionType, IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum v10_OperationType, bool v11_ParameterTakesPrecedence, bool v12_Sizeable); @@ -18434,13 +16400,7 @@ public: /// Edge radius according the above illustration (= r2). double EdgeRadius() const; void setEdgeRadius(double v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcPositiveLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "Depth"; case 4: return "FlangeWidth"; case 5: return "WebThickness"; case 6: return "FlangeThickness"; case 7: return "FilletRadius"; case 8: return "EdgeRadius"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcZShapeProfileDef (IfcAbstractEntity* e); IfcZShapeProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_EdgeRadius); @@ -18449,13 +16409,7 @@ public: class IfcAnnotationCurveOccurrence : public IfcAnnotationOccurrence { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcAnnotationOccurrence::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAnnotationCurveOccurrence (IfcAbstractEntity* e); IfcAnnotationCurveOccurrence (IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name); @@ -18495,13 +16449,7 @@ public: /// IFC2x Edition 3 CHANGE  The two new attributes OuterBoundary and InnerBoundaries replace the old single attribute Boundaries. IfcTemplatedEntityList< IfcCurve >::ptr InnerBoundaries() const; void setInnerBoundaries(IfcTemplatedEntityList< IfcCurve >::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCurve; case 1: return Type::IfcCurve; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "OuterBoundary"; case 1: return "InnerBoundaries"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAnnotationFillArea (IfcAbstractEntity* e); IfcAnnotationFillArea (IfcCurve* v1_OuterBoundary, boost::optional< IfcTemplatedEntityList< IfcCurve >::ptr > v2_InnerBoundaries); @@ -18518,13 +16466,7 @@ public: bool hasGlobalOrLocal() const; IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum GlobalOrLocal() const; void setGlobalOrLocal(IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENUMERATION; } return IfcAnnotationOccurrence::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPoint; case 4: return Type::IfcGlobalOrLocalEnum; } return IfcAnnotationOccurrence::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "FillStyleTarget"; case 4: return "GlobalOrLocal"; } return IfcAnnotationOccurrence::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAnnotationFillAreaOccurrence (IfcAbstractEntity* e); IfcAnnotationFillAreaOccurrence (IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, IfcPoint* v4_FillStyleTarget, boost::optional< IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum > v5_GlobalOrLocal); @@ -18539,13 +16481,7 @@ public: bool hasTextureCoordinates() const; IfcTextureCoordinate* TextureCoordinates() const; void setTextureCoordinates(IfcTextureCoordinate* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGeometricRepresentationItem; case 1: return Type::IfcTextureCoordinate; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Item"; case 1: return "TextureCoordinates"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAnnotationSurface (IfcAbstractEntity* e); IfcAnnotationSurface (IfcGeometricRepresentationItem* v1_Item, IfcTextureCoordinate* v2_TextureCoordinates); @@ -18567,13 +16503,7 @@ public: /// The direction of the local Z axis. IfcDirection* Axis() const; void setAxis(IfcDirection* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPlacement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcDirection; } return IfcPlacement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Axis"; } return IfcPlacement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAxis1Placement (IfcAbstractEntity* e); IfcAxis1Placement (IfcCartesianPoint* v1_Location, IfcDirection* v2_Axis); @@ -18597,13 +16527,7 @@ public: /// The direction used to determine the direction of the local X axis. If a value is omited that it defaults to [1.0, 0.0.]. IfcDirection* RefDirection() const; void setRefDirection(IfcDirection* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPlacement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcDirection; } return IfcPlacement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "RefDirection"; } return IfcPlacement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAxis2Placement2D (IfcAbstractEntity* e); IfcAxis2Placement2D (IfcCartesianPoint* v1_Location, IfcDirection* v2_RefDirection); @@ -18634,13 +16558,7 @@ public: /// The direction used to determine the direction of the local X Axis. If necessary an adjustment is made to maintain orthogonality to the Axis direction. If Axis and/or RefDirection is omitted, these directions are taken from the geometric coordinate system. IfcDirection* RefDirection() const; void setRefDirection(IfcDirection* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPlacement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcDirection; case 2: return Type::IfcDirection; } return IfcPlacement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Axis"; case 2: return "RefDirection"; } return IfcPlacement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAxis2Placement3D (IfcAbstractEntity* e); IfcAxis2Placement3D (IfcCartesianPoint* v1_Location, IfcDirection* v2_Axis, IfcDirection* v3_RefDirection); @@ -18683,13 +16601,7 @@ public: /// The second operand specified for the operation. IfcBooleanOperand* SecondOperand() const; void setSecondOperand(IfcBooleanOperand* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcBooleanOperator; case 1: return Type::IfcBooleanOperand; case 2: return Type::IfcBooleanOperand; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Operator"; case 1: return "FirstOperand"; case 2: return "SecondOperand"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBooleanResult (IfcAbstractEntity* e); IfcBooleanResult (IfcBooleanOperator::IfcBooleanOperator v1_Operator, IfcBooleanOperand* v2_FirstOperand, IfcBooleanOperand* v3_SecondOperand); @@ -18709,13 +16621,7 @@ public: /// A bounded surface has boundary curves. class IfcBoundedSurface : public IfcSurface { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcSurface::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcSurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcSurface::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoundedSurface (IfcAbstractEntity* e); IfcBoundedSurface (); @@ -18757,13 +16663,7 @@ public: /// Height attribute (measured along the edge parallel to the Z Axis). double ZDim() const; void setZDim(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCartesianPoint; case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcPositiveLengthMeasure; case 3: return Type::IfcPositiveLengthMeasure; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Corner"; case 1: return "XDim"; case 2: return "YDim"; case 3: return "ZDim"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoundingBox (IfcAbstractEntity* e); IfcBoundingBox (IfcCartesianPoint* v1_Corner, double v2_XDim, double v3_YDim, double v4_ZDim); @@ -18804,13 +16704,7 @@ public: /// The box which bounds the resulting solid of the Boolean operation involving the half space solid for computational purposes only. IfcBoundingBox* Enclosure() const; void setEnclosure(IfcBoundingBox* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcHalfSpaceSolid::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcBoundingBox; } return IfcHalfSpaceSolid::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Enclosure"; } return IfcHalfSpaceSolid::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoxedHalfSpace (IfcAbstractEntity* e); IfcBoxedHalfSpace (IfcSurface* v1_BaseSurface, bool v2_AgreementFlag, IfcBoundingBox* v3_Enclosure); @@ -18861,13 +16755,7 @@ public: bool hasCentreOfGravityInX() const; double CentreOfGravityInX() const; void setCentreOfGravityInX(double v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcPositiveLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "Depth"; case 4: return "Width"; case 5: return "WallThickness"; case 6: return "Girth"; case 7: return "InternalFilletRadius"; case 8: return "CentreOfGravityInX"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCShapeProfileDef (IfcAbstractEntity* e); IfcCShapeProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_Width, double v6_WallThickness, double v7_Girth, boost::optional< double > v8_InternalFilletRadius, boost::optional< double > v9_CentreOfGravityInX); @@ -18885,13 +16773,7 @@ public: /// The first, second, and third coordinate of the point location. If placed in a two or three dimensional rectangular Cartesian coordinate system, Coordinates[1] is the X coordinate, Coordinates[2] is the Y coordinate, and Coordinates[3] is the Z coordinate. std::vector< double > /*[1:3]*/ Coordinates() const; void setCoordinates(std::vector< double > /*[1:3]*/ v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } return IfcPoint::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLengthMeasure; } return IfcPoint::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Coordinates"; } return IfcPoint::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCartesianPoint (IfcAbstractEntity* e); IfcCartesianPoint (std::vector< double > /*[1:3]*/ v1_Coordinates); @@ -18947,13 +16829,7 @@ public: /// The scaling value specified for the transformation. double Scale() const; void setScale(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDirection; case 1: return Type::IfcDirection; case 2: return Type::IfcCartesianPoint; case 3: return Type::UNDEFINED; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Axis1"; case 1: return "Axis2"; case 2: return "LocalOrigin"; case 3: return "Scale"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCartesianTransformationOperator (IfcAbstractEntity* e); IfcCartesianTransformationOperator (IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale); @@ -18966,13 +16842,7 @@ public: /// HISTORY: New entity in IFC Release 2x. class IfcCartesianTransformationOperator2D : public IfcCartesianTransformationOperator { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcCartesianTransformationOperator::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcCartesianTransformationOperator::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcCartesianTransformationOperator::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCartesianTransformationOperator2D (IfcAbstractEntity* e); IfcCartesianTransformationOperator2D (IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale); @@ -18995,13 +16865,7 @@ public: /// The scaling value specified for the transformation along the axis 2. This is normally the y scale factor. double Scale2() const; void setScale2(double v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_DOUBLE; } return IfcCartesianTransformationOperator2D::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::UNDEFINED; } return IfcCartesianTransformationOperator2D::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "Scale2"; } return IfcCartesianTransformationOperator2D::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCartesianTransformationOperator2DnonUniform (IfcAbstractEntity* e); IfcCartesianTransformationOperator2DnonUniform (IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, boost::optional< double > v5_Scale2); @@ -19019,13 +16883,7 @@ public: /// The exact direction of U[3], the derived Z axis direction. IfcDirection* Axis3() const; void setAxis3(IfcDirection* v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcCartesianTransformationOperator::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcDirection; } return IfcCartesianTransformationOperator::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "Axis3"; } return IfcCartesianTransformationOperator::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCartesianTransformationOperator3D (IfcAbstractEntity* e); IfcCartesianTransformationOperator3D (IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, IfcDirection* v5_Axis3); @@ -19054,13 +16912,7 @@ public: /// The scaling value specified for the transformation along the axis 3. This is normally the z scale factor. double Scale3() const; void setScale3(double v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; } return IfcCartesianTransformationOperator3D::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::UNDEFINED; case 6: return Type::UNDEFINED; } return IfcCartesianTransformationOperator3D::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "Scale2"; case 6: return "Scale3"; } return IfcCartesianTransformationOperator3D::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCartesianTransformationOperator3DnonUniform (IfcAbstractEntity* e); IfcCartesianTransformationOperator3DnonUniform (IfcDirection* v1_Axis1, IfcDirection* v2_Axis2, IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, IfcDirection* v5_Axis3, boost::optional< double > v6_Scale2, boost::optional< double > v7_Scale3); @@ -19083,13 +16935,7 @@ public: /// The radius of the circle. double Radius() const; void setRadius(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "Radius"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCircleProfileDef (IfcAbstractEntity* e); IfcCircleProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Radius); @@ -19146,13 +16992,7 @@ public: /// 10303-42:1994, p.149 for the equation. class IfcClosedShell : public IfcConnectedFaceSet { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcConnectedFaceSet::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcConnectedFaceSet::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcConnectedFaceSet::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcClosedShell (IfcAbstractEntity* e); IfcClosedShell (IfcTemplatedEntityList< IfcFace >::ptr v1_CfsFaces); @@ -19178,14 +17018,8 @@ public: /// The bounded curve which defines the geometry of the segment. IfcCurve* ParentCurve() const; void setParentCurve(IfcCurve* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_BOOL; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcTransitionCode; case 1: return Type::UNDEFINED; case 2: return Type::IfcCurve; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Transition"; case 1: return "SameSense"; case 2: return "ParentCurve"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcCompositeCurve >::ptr UsingCurves() const; // INVERSE IfcCompositeCurve::Segments - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcCompositeCurve >::ptr UsingCurves() const; // INVERSE IfcCompositeCurve::Segments + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCompositeCurveSegment (IfcAbstractEntity* e); IfcCompositeCurveSegment (IfcTransitionCode::IfcTransitionCode v1_Transition, bool v2_SameSense, IfcCurve* v3_ParentCurve); @@ -19222,13 +17056,7 @@ public: bool hasCentreOfGravityInY() const; double CentreOfGravityInY() const; void setCentreOfGravityInY(double v); - virtual unsigned int getArgumentCount() const { return 15; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_DOUBLE; case 13: return IfcUtil::Argument_DOUBLE; case 14: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcPositiveLengthMeasure; case 9: return Type::IfcPositiveLengthMeasure; case 10: return Type::IfcPositiveLengthMeasure; case 11: return Type::IfcPositiveLengthMeasure; case 12: return Type::IfcPositiveLengthMeasure; case 13: return Type::IfcPositiveLengthMeasure; case 14: return Type::IfcPositiveLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "OverallHeight"; case 4: return "BaseWidth2"; case 5: return "Radius"; case 6: return "HeadWidth"; case 7: return "HeadDepth2"; case 8: return "HeadDepth3"; case 9: return "WebThickness"; case 10: return "BaseWidth4"; case 11: return "BaseDepth1"; case 12: return "BaseDepth2"; case 13: return "BaseDepth3"; case 14: return "CentreOfGravityInY"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCraneRailAShapeProfileDef (IfcAbstractEntity* e); IfcCraneRailAShapeProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallHeight, double v5_BaseWidth2, boost::optional< double > v6_Radius, double v7_HeadWidth, double v8_HeadDepth2, double v9_HeadDepth3, double v10_WebThickness, double v11_BaseWidth4, double v12_BaseDepth1, double v13_BaseDepth2, double v14_BaseDepth3, boost::optional< double > v15_CentreOfGravityInY); @@ -19259,13 +17087,7 @@ public: bool hasCentreOfGravityInY() const; double CentreOfGravityInY() const; void setCentreOfGravityInY(double v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcPositiveLengthMeasure; case 9: return Type::IfcPositiveLengthMeasure; case 10: return Type::IfcPositiveLengthMeasure; case 11: return Type::IfcPositiveLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "OverallHeight"; case 4: return "HeadWidth"; case 5: return "Radius"; case 6: return "HeadDepth2"; case 7: return "HeadDepth3"; case 8: return "WebThickness"; case 9: return "BaseDepth1"; case 10: return "BaseDepth2"; case 11: return "CentreOfGravityInY"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCraneRailFShapeProfileDef (IfcAbstractEntity* e); IfcCraneRailFShapeProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallHeight, double v5_HeadWidth, boost::optional< double > v6_Radius, double v7_HeadDepth2, double v8_HeadDepth3, double v9_WebThickness, double v10_BaseDepth1, double v11_BaseDepth2, boost::optional< double > v12_CentreOfGravityInY); @@ -19281,13 +17103,7 @@ public: /// The placement coordinate system to which the parameters of each individual CSG primitive apply. IfcAxis2Placement3D* Position() const; void setPosition(IfcAxis2Placement3D* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAxis2Placement3D; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Position"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCsgPrimitive3D (IfcAbstractEntity* e); IfcCsgPrimitive3D (IfcAxis2Placement3D* v1_Position); @@ -19339,13 +17155,7 @@ public: /// Boolean expression of primitives and regularized operators describing the solid. The root of the tree of Boolean expressions is given explicitly as an IfcBooleanResult entitiy or as a primitive (subtypes of IfcCsgPrimitive3D). IfcCsgSelect* TreeRootExpression() const; void setTreeRootExpression(IfcCsgSelect* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSolidModel::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCsgSelect; } return IfcSolidModel::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TreeRootExpression"; } return IfcSolidModel::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCsgSolid (IfcAbstractEntity* e); IfcCsgSolid (IfcCsgSelect* v1_TreeRootExpression); @@ -19363,13 +17173,7 @@ public: /// A curve shall have an arc length greater than zero. class IfcCurve : public IfcGeometricRepresentationItem { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCurve (IfcAbstractEntity* e); IfcCurve (); @@ -19399,13 +17203,7 @@ public: /// An optional set of inner boundaries. They shall not intersect each other or the outer boundary. IfcTemplatedEntityList< IfcCurve >::ptr InnerBoundaries() const; void setInnerBoundaries(IfcTemplatedEntityList< IfcCurve >::ptr v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcBoundedSurface::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPlane; case 1: return Type::IfcCurve; case 2: return Type::IfcCurve; } return IfcBoundedSurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BasisSurface"; case 1: return "OuterBoundary"; case 2: return "InnerBoundaries"; } return IfcBoundedSurface::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCurveBoundedPlane (IfcAbstractEntity* e); IfcCurveBoundedPlane (IfcPlane* v1_BasisSurface, IfcCurve* v2_OuterBoundary, IfcTemplatedEntityList< IfcCurve >::ptr v3_InnerBoundaries); @@ -19426,13 +17224,7 @@ public: /// A description of the placement, orientation and (uniform or non-uniform) scaling of the defined symbol. IfcCartesianTransformationOperator2D* Target() const; void setTarget(IfcCartesianTransformationOperator2D* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDefinedSymbolSelect; case 1: return Type::IfcCartesianTransformationOperator2D; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Definition"; case 1: return "Target"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDefinedSymbol (IfcAbstractEntity* e); IfcDefinedSymbol (IfcDefinedSymbolSelect* v1_Definition, IfcCartesianTransformationOperator2D* v2_Target); @@ -19441,14 +17233,8 @@ public: class IfcDimensionCurve : public IfcAnnotationCurveOccurrence { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcAnnotationCurveOccurrence::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcAnnotationCurveOccurrence::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcAnnotationCurveOccurrence::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcTerminatorSymbol >::ptr AnnotatedBySymbols() const; // INVERSE IfcTerminatorSymbol::AnnotatedCurve - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcTerminatorSymbol >::ptr AnnotatedBySymbols() const; // INVERSE IfcTerminatorSymbol::AnnotatedCurve + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDimensionCurve (IfcAbstractEntity* e); IfcDimensionCurve (IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name); @@ -19459,13 +17245,7 @@ class IfcDimensionCurveTerminator : public IfcTerminatorSymbol { public: IfcDimensionExtentUsage::IfcDimensionExtentUsage Role() const; void setRole(IfcDimensionExtentUsage::IfcDimensionExtentUsage v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENUMERATION; } return IfcTerminatorSymbol::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcDimensionExtentUsage; } return IfcTerminatorSymbol::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "Role"; } return IfcTerminatorSymbol::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDimensionCurveTerminator (IfcAbstractEntity* e); IfcDimensionCurveTerminator (IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, IfcAnnotationCurveOccurrence* v4_AnnotatedCurve, IfcDimensionExtentUsage::IfcDimensionExtentUsage v5_Role); @@ -19483,13 +17263,7 @@ public: /// The components in the direction of X axis (DirectionRatios[1]), of Y axis (DirectionRatios[2]), and of Z axis (DirectionRatios[3]) std::vector< double > /*[2:3]*/ DirectionRatios() const; void setDirectionRatios(std::vector< double > /*[2:3]*/ v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::UNDEFINED; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "DirectionRatios"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDirection (IfcAbstractEntity* e); IfcDirection (std::vector< double > /*[2:3]*/ v1_DirectionRatios); @@ -19649,13 +17423,7 @@ public: /// IFC2x4 CHANGE The attribute is deprecated and shall no longer be used, i.e. the value shall be NIL ($). IfcShapeAspect* ShapeAspectStyle() const; void setShapeAspectStyle(IfcShapeAspect* v); - virtual unsigned int getArgumentCount() const { return 15; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_DOUBLE; case 13: return IfcUtil::Argument_DOUBLE; case 14: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcPositiveLengthMeasure; case 9: return Type::IfcLengthMeasure; case 10: return Type::IfcLengthMeasure; case 11: return Type::IfcLengthMeasure; case 12: return Type::IfcPositiveLengthMeasure; case 13: return Type::IfcPositiveLengthMeasure; case 14: return Type::IfcShapeAspect; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "LiningDepth"; case 5: return "LiningThickness"; case 6: return "ThresholdDepth"; case 7: return "ThresholdThickness"; case 8: return "TransomThickness"; case 9: return "TransomOffset"; case 10: return "LiningOffset"; case 11: return "ThresholdOffset"; case 12: return "CasingThickness"; case 13: return "CasingDepth"; case 14: return "ShapeAspectStyle"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDoorLiningProperties (IfcAbstractEntity* e); IfcDoorLiningProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_LiningDepth, boost::optional< double > v6_LiningThickness, boost::optional< double > v7_ThresholdDepth, boost::optional< double > v8_ThresholdThickness, boost::optional< double > v9_TransomThickness, boost::optional< double > v10_TransomOffset, boost::optional< double > v11_LiningOffset, boost::optional< double > v12_ThresholdOffset, boost::optional< double > v13_CasingThickness, boost::optional< double > v14_CasingDepth, IfcShapeAspect* v15_ShapeAspectStyle); @@ -19731,13 +17499,7 @@ public: /// IFC2x4 CHANGE The attribute is deprecated and shall no longer be used, i.e. the value shall be NIL ($). IfcShapeAspect* ShapeAspectStyle() const; void setShapeAspectStyle(IfcShapeAspect* v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_ENUMERATION; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcDoorPanelOperationEnum; case 6: return Type::IfcNormalisedRatioMeasure; case 7: return Type::IfcDoorPanelPositionEnum; case 8: return Type::IfcShapeAspect; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "PanelDepth"; case 5: return "PanelOperation"; case 6: return "PanelWidth"; case 7: return "PanelPosition"; case 8: return "ShapeAspectStyle"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDoorPanelProperties (IfcAbstractEntity* e); IfcDoorPanelProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_PanelDepth, IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum v6_PanelOperation, boost::optional< double > v7_PanelWidth, IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum v8_PanelPosition, IfcShapeAspect* v9_ShapeAspectStyle); @@ -19783,13 +17545,7 @@ public: /// The Boolean indicates, whether the attached IfcMappedRepresentation (if given) can be sized (using scale factor of transformation), or not (FALSE). If not, the IfcMappedRepresentation should be IfcShapeRepresentation of the IfcDoor (using IfcMappedItem as the Item) with the scale factor = 1. bool Sizeable() const; void setSizeable(bool v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_ENUMERATION; case 10: return IfcUtil::Argument_BOOL; case 11: return IfcUtil::Argument_BOOL; } return IfcTypeProduct::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcDoorStyleOperationEnum; case 9: return Type::IfcDoorStyleConstructionEnum; case 10: return Type::UNDEFINED; case 11: return Type::UNDEFINED; } return IfcTypeProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "OperationType"; case 9: return "ConstructionType"; case 10: return "ParameterTakesPrecedence"; case 11: return "Sizeable"; } return IfcTypeProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDoorStyle (IfcAbstractEntity* e); IfcDoorStyle (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum v9_OperationType, IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum v10_ConstructionType, bool v11_ParameterTakesPrecedence, bool v12_Sizeable); @@ -19800,15 +17556,9 @@ class IfcDraughtingCallout : public IfcGeometricRepresentationItem { public: IfcEntityList::ptr Contents() const; void setContents(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDraughtingCalloutElement; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Contents"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcDraughtingCalloutRelationship >::ptr IsRelatedFromCallout() const; // INVERSE IfcDraughtingCalloutRelationship::RelatedDraughtingCallout + IfcTemplatedEntityList< IfcDraughtingCalloutRelationship >::ptr IsRelatedFromCallout() const; // INVERSE IfcDraughtingCalloutRelationship::RelatedDraughtingCallout IfcTemplatedEntityList< IfcDraughtingCalloutRelationship >::ptr IsRelatedToCallout() const; // INVERSE IfcDraughtingCalloutRelationship::RelatingDraughtingCallout - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDraughtingCallout (IfcAbstractEntity* e); IfcDraughtingCallout (IfcEntityList::ptr v1_Contents); @@ -19888,13 +17638,7 @@ public: /// The value 'by layer' shall only be inserted, if the geometric representation item using the colour definition has an association to IfcPresentationLayerWithStyle, and if that instance of IfcPresentationLayerWithStyle has a valid colour definition for IfcCurveStyle, IfcSymbolStyle, or IfcSurfaceStyle (depending on what is applicable). class IfcDraughtingPreDefinedColour : public IfcPreDefinedColour { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPreDefinedColour::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPreDefinedColour::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPreDefinedColour::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDraughtingPreDefinedColour (IfcAbstractEntity* e); IfcDraughtingPreDefinedColour (std::string v1_Name); @@ -19915,13 +17659,7 @@ public: /// HISTORY  New entity in IFC2x2. class IfcDraughtingPreDefinedCurveFont : public IfcPreDefinedCurveFont { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPreDefinedCurveFont::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPreDefinedCurveFont::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPreDefinedCurveFont::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDraughtingPreDefinedCurveFont (IfcAbstractEntity* e); IfcDraughtingPreDefinedCurveFont (std::string v1_Name); @@ -19943,13 +17681,7 @@ public: /// A list of oriented edge entities which are concatenated together to form this path. IfcTemplatedEntityList< IfcOrientedEdge >::ptr EdgeList() const; void setEdgeList(IfcTemplatedEntityList< IfcOrientedEdge >::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcLoop::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcOrientedEdge; } return IfcLoop::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "EdgeList"; } return IfcLoop::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEdgeLoop (IfcAbstractEntity* e); IfcEdgeLoop (IfcTemplatedEntityList< IfcOrientedEdge >::ptr v1_EdgeList); @@ -20044,13 +17776,7 @@ public: /// The individual quantities for the element, can be a set of length, area, volume, weight or count based quantities. IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr Quantities() const; void setQuantities(IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcLabel; case 5: return Type::IfcPhysicalQuantity; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "MethodOfMeasurement"; case 5: return "Quantities"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElementQuantity (IfcAbstractEntity* e); IfcElementQuantity (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_MethodOfMeasurement, IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v6_Quantities); @@ -20085,13 +17811,7 @@ public: /// The type denotes a particular type that indicates the object further. The use has to be established at the level of instantiable subtypes. In particular it holds the user defined type, if the enumeration of the attribute 'PredefinedType' is set to USERDEFINED. std::string ElementType() const; void setElementType(std::string v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_STRING; } return IfcTypeProduct::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcLabel; } return IfcTypeProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "ElementType"; } return IfcTypeProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElementType (IfcAbstractEntity* e); IfcElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -20107,13 +17827,7 @@ public: /// The position and orientation of the surface. This attribute is used in the definition of the parameterization of the surface. IfcAxis2Placement3D* Position() const; void setPosition(IfcAxis2Placement3D* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSurface::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAxis2Placement3D; } return IfcSurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Position"; } return IfcSurface::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElementarySurface (IfcAbstractEntity* e); IfcElementarySurface (IfcAxis2Placement3D* v1_Position); @@ -20143,13 +17857,7 @@ public: /// The second radius of the ellipse. It is measured along the direction of Position.P[2]. double SemiAxis2() const; void setSemiAxis2(double v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "SemiAxis1"; case 4: return "SemiAxis2"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEllipseProfileDef (IfcAbstractEntity* e); IfcEllipseProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_SemiAxis1, double v5_SemiAxis2); @@ -20166,13 +17874,7 @@ public: bool hasUserDefinedEnergySequence() const; std::string UserDefinedEnergySequence() const; void setUserDefinedEnergySequence(std::string v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_STRING; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcEnergySequenceEnum; case 5: return Type::IfcLabel; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "EnergySequence"; case 5: return "UserDefinedEnergySequence"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEnergyProperties (IfcAbstractEntity* e); IfcEnergyProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcEnergySequenceEnum::IfcEnergySequenceEnum > v5_EnergySequence, boost::optional< std::string > v6_UserDefinedEnergySequence); @@ -20255,13 +17957,7 @@ public: /// . double Depth() const; void setDepth(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcSweptAreaSolid::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcDirection; case 3: return Type::IfcPositiveLengthMeasure; } return IfcSweptAreaSolid::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "ExtrudedDirection"; case 3: return "Depth"; } return IfcSweptAreaSolid::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExtrudedAreaSolid (IfcAbstractEntity* e); IfcExtrudedAreaSolid (IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcDirection* v3_ExtrudedDirection, double v4_Depth); @@ -20284,13 +17980,7 @@ public: /// The set of connected face sets comprising the face based surface model. IfcTemplatedEntityList< IfcConnectedFaceSet >::ptr FbsmFaces() const; void setFbsmFaces(IfcTemplatedEntityList< IfcConnectedFaceSet >::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcConnectedFaceSet; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "FbsmFaces"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFaceBasedSurfaceModel (IfcAbstractEntity* e); IfcFaceBasedSurfaceModel (IfcTemplatedEntityList< IfcConnectedFaceSet >::ptr v1_FbsmFaces); @@ -20372,13 +18062,7 @@ public: /// A plane angle measure determining the direction of the parallel hatching lines. double HatchLineAngle() const; void setHatchLineAngle(double v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_DOUBLE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCurveStyle; case 1: return Type::IfcHatchLineDistanceSelect; case 2: return Type::IfcCartesianPoint; case 3: return Type::IfcCartesianPoint; case 4: return Type::IfcPlaneAngleMeasure; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "HatchLineAppearance"; case 1: return "StartOfNextHatchLine"; case 2: return "PointOfReferenceHatchLine"; case 3: return "PatternStart"; case 4: return "HatchLineAngle"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFillAreaStyleHatching (IfcAbstractEntity* e); IfcFillAreaStyleHatching (IfcCurveStyle* v1_HatchLineAppearance, IfcHatchLineDistanceSelect* v2_StartOfNextHatchLine, IfcCartesianPoint* v3_PointOfReferenceHatchLine, IfcCartesianPoint* v4_PatternStart, double v5_HatchLineAngle); @@ -20400,13 +18084,7 @@ public: /// NOTE Only IfcStyleItem's that refer to a compatible geometric representation item and presentation style shall be used. IfcAnnotationSymbolOccurrence* Symbol() const; void setSymbol(IfcAnnotationSymbolOccurrence* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAnnotationSymbolOccurrence; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Symbol"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFillAreaStyleTileSymbolWithStyle (IfcAbstractEntity* e); IfcFillAreaStyleTileSymbolWithStyle (IfcAnnotationSymbolOccurrence* v1_Symbol); @@ -20428,13 +18106,7 @@ public: /// The scale factor applied to each tile as it is placed in the annotation fill area. double TilingScale() const; void setTilingScale(double v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_DOUBLE; } return IfcGeometricRepresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcOneDirectionRepeatFactor; case 1: return Type::IfcFillAreaStyleTileShapeSelect; case 2: return Type::IfcPositiveRatioMeasure; } return IfcGeometricRepresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TilingPattern"; case 1: return "Tiles"; case 2: return "TilingScale"; } return IfcGeometricRepresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFillAreaStyleTiles (IfcAbstractEntity* e); IfcFillAreaStyleTiles (IfcOneDirectionRepeatFactor* v1_TilingPattern, IfcEntityList::ptr v2_Tiles, double v3_TilingScale); @@ -20499,13 +18171,7 @@ public: bool hasPressureSingleValue() const; double PressureSingleValue() const; void setPressureSingleValue(double v); - virtual unsigned int getArgumentCount() const { return 19; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_STRING; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_DOUBLE; case 13: return IfcUtil::Argument_ENTITY_INSTANCE; case 14: return IfcUtil::Argument_ENTITY_INSTANCE; case 15: return IfcUtil::Argument_ENTITY_INSTANCE; case 16: return IfcUtil::Argument_DOUBLE; case 17: return IfcUtil::Argument_DOUBLE; case 18: return IfcUtil::Argument_DOUBLE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPropertySourceEnum; case 5: return Type::IfcTimeSeries; case 6: return Type::IfcTimeSeries; case 7: return Type::IfcTimeSeries; case 8: return Type::IfcMaterial; case 9: return Type::IfcTimeSeries; case 10: return Type::IfcLabel; case 11: return Type::IfcThermodynamicTemperatureMeasure; case 12: return Type::IfcThermodynamicTemperatureMeasure; case 13: return Type::IfcTimeSeries; case 14: return Type::IfcTimeSeries; case 15: return Type::IfcDerivedMeasureValue; case 16: return Type::IfcPositiveRatioMeasure; case 17: return Type::IfcLinearVelocityMeasure; case 18: return Type::IfcPressureMeasure; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "PropertySource"; case 5: return "FlowConditionTimeSeries"; case 6: return "VelocityTimeSeries"; case 7: return "FlowrateTimeSeries"; case 8: return "Fluid"; case 9: return "PressureTimeSeries"; case 10: return "UserDefinedPropertySource"; case 11: return "TemperatureSingleValue"; case 12: return "WetBulbTemperatureSingleValue"; case 13: return "WetBulbTemperatureTimeSeries"; case 14: return "TemperatureTimeSeries"; case 15: return "FlowrateSingleValue"; case 16: return "FlowConditionSingleValue"; case 17: return "VelocitySingleValue"; case 18: return "PressureSingleValue"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFluidFlowProperties (IfcAbstractEntity* e); IfcFluidFlowProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPropertySourceEnum::IfcPropertySourceEnum v5_PropertySource, IfcTimeSeries* v6_FlowConditionTimeSeries, IfcTimeSeries* v7_VelocityTimeSeries, IfcTimeSeries* v8_FlowrateTimeSeries, IfcMaterial* v9_Fluid, IfcTimeSeries* v10_PressureTimeSeries, boost::optional< std::string > v11_UserDefinedPropertySource, boost::optional< double > v12_TemperatureSingleValue, boost::optional< double > v13_WetBulbTemperatureSingleValue, IfcTimeSeries* v14_WetBulbTemperatureTimeSeries, IfcTimeSeries* v15_TemperatureTimeSeries, IfcDerivedMeasureValue* v16_FlowrateSingleValue, boost::optional< double > v17_FlowConditionSingleValue, boost::optional< double > v18_VelocitySingleValue, boost::optional< double > v19_PressureSingleValue); @@ -20541,13 +18207,7 @@ public: /// IFC2x4. class IfcFurnishingElementType : public IfcElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFurnishingElementType (IfcAbstractEntity* e); IfcFurnishingElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -20595,13 +18255,7 @@ public: /// A designation of where the assembly is intended to take place. A selection of alternatives s provided in an enumerated list. IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum AssemblyPlace() const; void setAssemblyPlace(IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFurnishingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcAssemblyPlaceEnum; } return IfcFurnishingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "AssemblyPlace"; } return IfcFurnishingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFurnitureType (IfcAbstractEntity* e); IfcFurnitureType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum v10_AssemblyPlace); @@ -20616,13 +18270,7 @@ public: /// HISTORY: New entity in IFC2x2. class IfcGeometricCurveSet : public IfcGeometricSet { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcGeometricSet::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcGeometricSet::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcGeometricSet::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGeometricCurveSet (IfcAbstractEntity* e); IfcGeometricCurveSet (IfcEntityList::ptr v1_Elements); @@ -20710,13 +18358,7 @@ public: /// The fillet between the web and the flange. double FilletRadius() const; void setFilletRadius(double v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "OverallWidth"; case 4: return "OverallDepth"; case 5: return "WebThickness"; case 6: return "FlangeThickness"; case 7: return "FilletRadius"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcIShapeProfileDef (IfcAbstractEntity* e); IfcIShapeProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallWidth, double v5_OverallDepth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius); @@ -20809,13 +18451,7 @@ public: bool hasCentreOfGravityInY() const; double CentreOfGravityInY() const; void setCentreOfGravityInY(double v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; } return IfcParameterizedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcPositiveLengthMeasure; case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcPlaneAngleMeasure; case 9: return Type::IfcPositiveLengthMeasure; case 10: return Type::IfcPositiveLengthMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "Depth"; case 4: return "Width"; case 5: return "Thickness"; case 6: return "FilletRadius"; case 7: return "EdgeRadius"; case 8: return "LegSlope"; case 9: return "CentreOfGravityInX"; case 10: return "CentreOfGravityInY"; } return IfcParameterizedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLShapeProfileDef (IfcAbstractEntity* e); IfcLShapeProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Depth, boost::optional< double > v5_Width, double v6_Thickness, boost::optional< double > v7_FilletRadius, boost::optional< double > v8_EdgeRadius, boost::optional< double > v9_LegSlope, boost::optional< double > v10_CentreOfGravityInX, boost::optional< double > v11_CentreOfGravityInY); @@ -20842,13 +18478,7 @@ public: /// The direction of the line, the magnitude and units of Dir affect the parameterization of the line. IfcVector* Dir() const; void setDir(IfcVector* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCartesianPoint; case 1: return Type::IfcVector; } return IfcCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Pnt"; case 1: return "Dir"; } return IfcCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLine (IfcAbstractEntity* e); IfcLine (IfcCartesianPoint* v1_Pnt, IfcVector* v2_Dir); @@ -20922,13 +18552,7 @@ public: /// A closed shell defining the exterior boundary of the solid. The shell normal shall point away from the interior of the solid. IfcClosedShell* Outer() const; void setOuter(IfcClosedShell* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSolidModel::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcClosedShell; } return IfcSolidModel::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Outer"; } return IfcSolidModel::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcManifoldSolidBrep (IfcAbstractEntity* e); IfcManifoldSolidBrep (IfcClosedShell* v1_Outer); @@ -21023,14 +18647,8 @@ public: /// The type denotes a particular type that indicates the object further. The use has to be established at the level of instantiable subtypes. In particular it holds the user defined type, if the enumeration of the attribute PredefinedType is set to USERDEFINED. std::string ObjectType() const; void setObjectType(std::string v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_STRING; } return IfcObjectDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcLabel; } return IfcObjectDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "ObjectType"; } return IfcObjectDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelDefines >::ptr IsDefinedBy() const; // INVERSE IfcRelDefines::RelatedObjects - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelDefines >::ptr IsDefinedBy() const; // INVERSE IfcRelDefines::RelatedObjects + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcObject (IfcAbstractEntity* e); IfcObject (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -21058,13 +18676,7 @@ public: /// An indication of whether the offset curve self-intersects; this is for information only. bool SelfIntersect() const; void setSelfIntersect(bool v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_BOOL; } return IfcCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCurve; case 1: return Type::IfcLengthMeasure; case 2: return Type::UNDEFINED; } return IfcCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BasisCurve"; case 1: return "Distance"; case 2: return "SelfIntersect"; } return IfcCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOffsetCurve2D (IfcAbstractEntity* e); IfcOffsetCurve2D (IfcCurve* v1_BasisCurve, double v2_Distance, bool v3_SelfIntersect); @@ -21099,13 +18711,7 @@ public: /// The direction used to define the direction of the offset curve 3d from the basis curve. IfcDirection* RefDirection() const; void setRefDirection(IfcDirection* v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_BOOL; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCurve; case 1: return Type::IfcLengthMeasure; case 2: return Type::UNDEFINED; case 3: return Type::IfcDirection; } return IfcCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BasisCurve"; case 1: return "Distance"; case 2: return "SelfIntersect"; case 3: return "RefDirection"; } return IfcCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOffsetCurve3D (IfcAbstractEntity* e); IfcOffsetCurve3D (IfcCurve* v1_BasisCurve, double v2_Distance, bool v3_SelfIntersect, IfcDirection* v4_RefDirection); @@ -21165,13 +18771,7 @@ public: /// Optional link to a shape aspect definition, which points to the part of the geometric representation of the window style, which is used to represent the permeable covering. IfcShapeAspect* ShapeAspectStyle() const; void setShapeAspectStyle(IfcShapeAspect* v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPermeableCoveringOperationEnum; case 5: return Type::IfcWindowPanelPositionEnum; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; case 8: return Type::IfcShapeAspect; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "OperationType"; case 5: return "PanelPosition"; case 6: return "FrameDepth"; case 7: return "FrameThickness"; case 8: return "ShapeAspectStyle"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPermeableCoveringProperties (IfcAbstractEntity* e); IfcPermeableCoveringProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum v5_OperationType, IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum v6_PanelPosition, boost::optional< double > v7_FrameDepth, boost::optional< double > v8_FrameThickness, IfcShapeAspect* v9_ShapeAspectStyle); @@ -21189,13 +18789,7 @@ public: /// NOTE  In case of a 3D placement by IfcAxisPlacement3D the IfcPlanarBox is defined within the xy plane of the definition coordinate system. IfcAxis2Placement* Placement() const; void setPlacement(IfcAxis2Placement* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcPlanarExtent::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcAxis2Placement; } return IfcPlanarExtent::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Placement"; } return IfcPlanarExtent::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPlanarBox (IfcAbstractEntity* e); IfcPlanarBox (double v1_SizeInX, double v2_SizeInY, IfcAxis2Placement* v3_Placement); @@ -21239,13 +18833,7 @@ public: /// HISTORY New class in IFC Release 1.5 class IfcPlane : public IfcElementarySurface { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElementarySurface::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElementarySurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElementarySurface::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPlane (IfcAbstractEntity* e); IfcPlane (IfcAxis2Placement3D* v1_Position); @@ -21293,16 +18881,10 @@ public: /// as a mechanism to a process, such as labor, material and equipment in cost calculations. class IfcProcess : public IfcObject { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcObject::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssignsToProcess >::ptr OperatesOn() const; // INVERSE IfcRelAssignsToProcess::RelatingProcess + IfcTemplatedEntityList< IfcRelAssignsToProcess >::ptr OperatesOn() const; // INVERSE IfcRelAssignsToProcess::RelatingProcess IfcTemplatedEntityList< IfcRelSequence >::ptr IsSuccessorFrom() const; // INVERSE IfcRelSequence::RelatedProcess IfcTemplatedEntityList< IfcRelSequence >::ptr IsPredecessorTo() const; // INVERSE IfcRelSequence::RelatingProcess - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProcess (IfcAbstractEntity* e); IfcProcess (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -21411,14 +18993,8 @@ public: /// Reference to the representations of the product, being either a representation (IfcProductRepresentation) or as a special case a shape representations (IfcProductDefinitionShape). The product definition shape provides for multiple geometric representations of the shape property of the object within the same object coordinate system, defined by the object placement. IfcProductRepresentation* Representation() const; void setRepresentation(IfcProductRepresentation* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcObjectPlacement; case 6: return Type::IfcProductRepresentation; } return IfcObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "ObjectPlacement"; case 6: return "Representation"; } return IfcObject::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssignsToProduct >::ptr ReferencedBy() const; // INVERSE IfcRelAssignsToProduct::RelatingProduct - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelAssignsToProduct >::ptr ReferencedBy() const; // INVERSE IfcRelAssignsToProduct::RelatingProduct + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProduct (IfcAbstractEntity* e); IfcProduct (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation); @@ -21482,13 +19058,7 @@ public: void setRepresentationContexts(IfcTemplatedEntityList< IfcRepresentationContext >::ptr v); IfcUnitAssignment* UnitsInContext() const; void setUnitsInContext(IfcUnitAssignment* v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcLabel; case 6: return Type::IfcLabel; case 7: return Type::IfcRepresentationContext; case 8: return Type::IfcUnitAssignment; } return IfcObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "LongName"; case 6: return "Phase"; case 7: return "RepresentationContexts"; case 8: return "UnitsInContext"; } return IfcObject::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProject (IfcAbstractEntity* e); IfcProject (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_LongName, boost::optional< std::string > v7_Phase, IfcTemplatedEntityList< IfcRepresentationContext >::ptr v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext); @@ -21497,13 +19067,7 @@ public: class IfcProjectionCurve : public IfcAnnotationCurveOccurrence { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcAnnotationCurveOccurrence::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcAnnotationCurveOccurrence::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcAnnotationCurveOccurrence::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProjectionCurve (IfcAbstractEntity* e); IfcProjectionCurve (IfcRepresentationItem* v1_Item, IfcTemplatedEntityList< IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name); @@ -21567,13 +19131,7 @@ public: /// Contained set of properties. For property sets defined as part of the IFC Object model, the property objects within a property set are defined as part of the standard. If a property is not contained within the set of predefined properties, its value has not been set at this time. IfcTemplatedEntityList< IfcProperty >::ptr HasProperties() const; void setHasProperties(IfcTemplatedEntityList< IfcProperty >::ptr v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcProperty; } return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "HasProperties"; } return IfcPropertySetDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertySet (IfcAbstractEntity* e); IfcPropertySet (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcProperty >::ptr v5_HasProperties); @@ -21605,13 +19163,7 @@ public: /// The tag (or label) identifier at the particular instance of a product, e.g. the serial number, or the position number. It is the identifier at the occurrence level. std::string Tag() const; void setTag(std::string v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_ENUMERATION; case 8: return IfcUtil::Argument_STRING; } return IfcProduct::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcObjectTypeEnum; case 8: return Type::IfcLabel; } return IfcProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "ProxyType"; case 8: return "Tag"; } return IfcProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProxy (IfcAbstractEntity* e); IfcProxy (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcObjectTypeEnum::IfcObjectTypeEnum v8_ProxyType, boost::optional< std::string > v9_Tag); @@ -21652,13 +19204,7 @@ public: /// Outer corner radius. double OuterFilletRadius() const; void setOuterFilletRadius(double v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; } return IfcRectangleProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcPositiveLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcPositiveLengthMeasure; } return IfcRectangleProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "WallThickness"; case 6: return "InnerFilletRadius"; case 7: return "OuterFilletRadius"; } return IfcRectangleProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRectangleHollowProfileDef (IfcAbstractEntity* e); IfcRectangleHollowProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim, double v6_WallThickness, boost::optional< double > v7_InnerFilletRadius, boost::optional< double > v8_OuterFilletRadius); @@ -21763,13 +19309,7 @@ public: /// The height of the apex above the plane of the base, measured in the direction of the placement Z axis, the SELF\IfcCsgPrimitive3D.Position.P[2]. double Height() const; void setHeight(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcCsgPrimitive3D::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcPositiveLengthMeasure; case 3: return Type::IfcPositiveLengthMeasure; } return IfcCsgPrimitive3D::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "XLength"; case 2: return "YLength"; case 3: return "Height"; } return IfcCsgPrimitive3D::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRectangularPyramid (IfcAbstractEntity* e); IfcRectangularPyramid (IfcAxis2Placement3D* v1_Position, double v2_XLength, double v3_YLength, double v4_Height); @@ -21813,13 +19353,7 @@ public: /// Flag to indicate whether the direction of the second parameter of the trimmed surface agrees with or opposes the sense of v in the basis surface. bool Vsense() const; void setVsense(bool v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_BOOL; case 6: return IfcUtil::Argument_BOOL; } return IfcBoundedSurface::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcSurface; case 1: return Type::IfcParameterValue; case 2: return Type::IfcParameterValue; case 3: return Type::IfcParameterValue; case 4: return Type::IfcParameterValue; case 5: return Type::UNDEFINED; case 6: return Type::UNDEFINED; } return IfcBoundedSurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BasisSurface"; case 1: return "U1"; case 2: return "V1"; case 3: return "U2"; case 4: return "V2"; case 5: return "Usense"; case 6: return "Vsense"; } return IfcBoundedSurface::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRectangularTrimmedSurface (IfcAbstractEntity* e); IfcRectangularTrimmedSurface (IfcSurface* v1_BasisSurface, double v2_U1, double v3_V1, double v4_U2, double v5_V2, bool v6_Usense, bool v7_Vsense); @@ -21847,13 +19381,7 @@ public: /// IFC2x4 CHANGE  The attribute is deprecated and shall no longer be used. A NIL value should always be assigned. IfcObjectTypeEnum::IfcObjectTypeEnum RelatedObjectsType() const; void setRelatedObjectsType(IfcObjectTypeEnum::IfcObjectTypeEnum v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENUMERATION; } return IfcRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcObjectDefinition; case 5: return Type::IfcObjectTypeEnum; } return IfcRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatedObjects"; case 5: return "RelatedObjectsType"; } return IfcRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssigns (IfcAbstractEntity* e); IfcRelAssigns (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType); @@ -21878,13 +19406,7 @@ public: /// Role of the actor played within the context of the assignment to the object(s). IfcActorRole* ActingRole() const; void setActingRole(IfcActorRole* v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssigns::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcActor; case 7: return Type::IfcActorRole; } return IfcRelAssigns::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "RelatingActor"; case 7: return "ActingRole"; } return IfcRelAssigns::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssignsToActor (IfcAbstractEntity* e); IfcRelAssignsToActor (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcActor* v7_RelatingActor, IfcActorRole* v8_ActingRole); @@ -21900,13 +19422,7 @@ public: /// Reference to the IfcControl that applies a control upon objects. IfcControl* RelatingControl() const; void setRelatingControl(IfcControl* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssigns::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcControl; } return IfcRelAssigns::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "RelatingControl"; } return IfcRelAssigns::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssignsToControl (IfcAbstractEntity* e); IfcRelAssignsToControl (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl); @@ -21930,13 +19446,7 @@ public: /// Reference to group that contains all assigned group members. IfcGroup* RelatingGroup() const; void setRelatingGroup(IfcGroup* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssigns::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcGroup; } return IfcRelAssigns::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "RelatingGroup"; } return IfcRelAssigns::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssignsToGroup (IfcAbstractEntity* e); IfcRelAssignsToGroup (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcGroup* v7_RelatingGroup); @@ -21976,13 +19486,7 @@ public: /// Quantity of the object specific for the operation by this process. IfcMeasureWithUnit* QuantityInProcess() const; void setQuantityInProcess(IfcMeasureWithUnit* v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssigns::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcProcess; case 7: return Type::IfcMeasureWithUnit; } return IfcRelAssigns::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "RelatingProcess"; case 7: return "QuantityInProcess"; } return IfcRelAssigns::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssignsToProcess (IfcAbstractEntity* e); IfcRelAssignsToProcess (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcProcess* v7_RelatingProcess, IfcMeasureWithUnit* v8_QuantityInProcess); @@ -22003,13 +19507,7 @@ public: /// IFC2x4 CHANGE Datatype expanded to include IfcProduct and IfcTypeProduct. IfcProduct* RelatingProduct() const; void setRelatingProduct(IfcProduct* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssigns::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcProduct; } return IfcRelAssigns::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "RelatingProduct"; } return IfcRelAssigns::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssignsToProduct (IfcAbstractEntity* e); IfcRelAssignsToProduct (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcProduct* v7_RelatingProduct); @@ -22018,13 +19516,7 @@ public: class IfcRelAssignsToProjectOrder : public IfcRelAssignsToControl { public: - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRelAssignsToControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRelAssignsToControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRelAssignsToControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssignsToProjectOrder (IfcAbstractEntity* e); IfcRelAssignsToProjectOrder (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl); @@ -22043,13 +19535,7 @@ public: /// IFC2x4 CHANGE Datatype expanded to include IfcResource and IfcTypeResource. IfcResource* RelatingResource() const; void setRelatingResource(IfcResource* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssigns::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcResource; } return IfcRelAssigns::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "RelatingResource"; } return IfcRelAssigns::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssignsToResource (IfcAbstractEntity* e); IfcRelAssignsToResource (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcResource* v7_RelatingResource); @@ -22103,13 +19589,7 @@ public: /// IFC2x4 CHANGE  The attribute datatype has been changed from IfcRoot to IfcDefinitionSelect. IfcTemplatedEntityList< IfcRoot >::ptr RelatedObjects() const; void setRelatedObjects(IfcTemplatedEntityList< IfcRoot >::ptr v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcRoot; } return IfcRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatedObjects"; } return IfcRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssociates (IfcAbstractEntity* e); IfcRelAssociates (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects); @@ -22120,13 +19600,7 @@ class IfcRelAssociatesAppliedValue : public IfcRelAssociates { public: IfcAppliedValue* RelatingAppliedValue() const; void setRelatingAppliedValue(IfcAppliedValue* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssociates::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcAppliedValue; } return IfcRelAssociates::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RelatingAppliedValue"; } return IfcRelAssociates::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssociatesAppliedValue (IfcAbstractEntity* e); IfcRelAssociatesAppliedValue (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcAppliedValue* v6_RelatingAppliedValue); @@ -22140,13 +19614,7 @@ public: /// Reference to approval that is being applied using this relationship. IfcApproval* RelatingApproval() const; void setRelatingApproval(IfcApproval* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssociates::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcApproval; } return IfcRelAssociates::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RelatingApproval"; } return IfcRelAssociates::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssociatesApproval (IfcAbstractEntity* e); IfcRelAssociatesApproval (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcApproval* v6_RelatingApproval); @@ -22187,13 +19655,7 @@ public: /// Classification applied to the objects. IfcClassificationNotationSelect* RelatingClassification() const; void setRelatingClassification(IfcClassificationNotationSelect* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssociates::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcClassificationNotationSelect; } return IfcRelAssociates::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RelatingClassification"; } return IfcRelAssociates::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssociatesClassification (IfcAbstractEntity* e); IfcRelAssociatesClassification (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcClassificationNotationSelect* v6_RelatingClassification); @@ -22210,13 +19672,7 @@ public: /// Reference to constraint that is being applied using this relationship. IfcConstraint* RelatingConstraint() const; void setRelatingConstraint(IfcConstraint* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssociates::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcLabel; case 6: return Type::IfcConstraint; } return IfcRelAssociates::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "Intent"; case 6: return "RelatingConstraint"; } return IfcRelAssociates::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssociatesConstraint (IfcAbstractEntity* e); IfcRelAssociatesConstraint (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, std::string v6_Intent, IfcConstraint* v7_RelatingConstraint); @@ -22234,13 +19690,7 @@ public: /// Document information or reference which is applied to the objects. IfcDocumentSelect* RelatingDocument() const; void setRelatingDocument(IfcDocumentSelect* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssociates::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcDocumentSelect; } return IfcRelAssociates::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RelatingDocument"; } return IfcRelAssociates::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssociatesDocument (IfcAbstractEntity* e); IfcRelAssociatesDocument (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcDocumentSelect* v6_RelatingDocument); @@ -22258,13 +19708,7 @@ public: /// Reference to a library, from which the definition of the property set is taken. IfcLibrarySelect* RelatingLibrary() const; void setRelatingLibrary(IfcLibrarySelect* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssociates::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcLibrarySelect; } return IfcRelAssociates::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RelatingLibrary"; } return IfcRelAssociates::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssociatesLibrary (IfcAbstractEntity* e); IfcRelAssociatesLibrary (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcLibrarySelect* v6_RelatingLibrary); @@ -22369,13 +19813,7 @@ public: /// Material definition assigned to the elements or element types. IfcMaterialSelect* RelatingMaterial() const; void setRelatingMaterial(IfcMaterialSelect* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssociates::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcMaterialSelect; } return IfcRelAssociates::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RelatingMaterial"; } return IfcRelAssociates::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssociatesMaterial (IfcAbstractEntity* e); IfcRelAssociatesMaterial (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcMaterialSelect* v6_RelatingMaterial); @@ -22394,13 +19832,7 @@ public: bool hasProfileOrientation() const; IfcOrientationSelect* ProfileOrientation() const; void setProfileOrientation(IfcOrientationSelect* v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssociates::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcProfileProperties; case 6: return Type::IfcShapeAspect; case 7: return Type::IfcOrientationSelect; } return IfcRelAssociates::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RelatingProfileProperties"; case 6: return "ProfileSectionLocation"; case 7: return "ProfileOrientation"; } return IfcRelAssociates::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssociatesProfileProperties (IfcAbstractEntity* e); IfcRelAssociatesProfileProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcRoot >::ptr v5_RelatedObjects, IfcProfileProperties* v6_RelatingProfileProperties, IfcShapeAspect* v7_ProfileSectionLocation, IfcOrientationSelect* v8_ProfileOrientation); @@ -22411,13 +19843,7 @@ public: /// HISTORY: New entity in IFC Release 2x. class IfcRelConnects : public IfcRelationship { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelConnects (IfcAbstractEntity* e); IfcRelConnects (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -22458,13 +19884,7 @@ public: /// Reference to a subtype of IfcElement that is connected by the connection relationship in the role of RelatedElement. IfcElement* RelatedElement() const; void setRelatedElement(IfcElement* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcConnectionGeometry; case 5: return Type::IfcElement; case 6: return Type::IfcElement; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "ConnectionGeometry"; case 5: return "RelatingElement"; case 6: return "RelatedElement"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelConnectsElements (IfcAbstractEntity* e); IfcRelConnectsElements (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcConnectionGeometry* v5_ConnectionGeometry, IfcElement* v6_RelatingElement, IfcElement* v7_RelatedElement); @@ -22516,13 +19936,7 @@ public: /// Indication of the connection type in relation to the path of the RelatingObject. IfcConnectionTypeEnum::IfcConnectionTypeEnum RelatingConnectionType() const; void setRelatingConnectionType(IfcConnectionTypeEnum::IfcConnectionTypeEnum v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_AGGREGATE_OF_INT; case 8: return IfcUtil::Argument_AGGREGATE_OF_INT; case 9: return IfcUtil::Argument_ENUMERATION; case 10: return IfcUtil::Argument_ENUMERATION; } return IfcRelConnectsElements::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::UNDEFINED; case 8: return Type::UNDEFINED; case 9: return Type::IfcConnectionTypeEnum; case 10: return Type::IfcConnectionTypeEnum; } return IfcRelConnectsElements::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "RelatingPriorities"; case 8: return "RelatedPriorities"; case 9: return "RelatedConnectionType"; case 10: return "RelatingConnectionType"; } return IfcRelConnectsElements::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelConnectsPathElements (IfcAbstractEntity* e); IfcRelConnectsPathElements (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcConnectionGeometry* v5_ConnectionGeometry, IfcElement* v6_RelatingElement, IfcElement* v7_RelatedElement, std::vector< int > /*[0:?]*/ v8_RelatingPriorities, std::vector< int > /*[0:?]*/ v9_RelatedPriorities, IfcConnectionTypeEnum::IfcConnectionTypeEnum v10_RelatedConnectionType, IfcConnectionTypeEnum::IfcConnectionTypeEnum v11_RelatingConnectionType); @@ -22563,13 +19977,7 @@ public: /// IFC2x4 CHANGE Data type extended to IfcObjectDefinition to enable elements and element types for the port relationship. IfcElement* RelatedElement() const; void setRelatedElement(IfcElement* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPort; case 5: return Type::IfcElement; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingPort"; case 5: return "RelatedElement"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelConnectsPortToElement (IfcAbstractEntity* e); IfcRelConnectsPortToElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPort* v5_RelatingPort, IfcElement* v6_RelatedElement); @@ -22601,13 +20009,7 @@ public: /// Defines the element that realizes a port connection relationship. IfcElement* RealizingElement() const; void setRealizingElement(IfcElement* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPort; case 5: return Type::IfcPort; case 6: return Type::IfcElement; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingPort"; case 5: return "RelatedPort"; case 6: return "RealizingElement"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelConnectsPorts (IfcAbstractEntity* e); IfcRelConnectsPorts (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcPort* v5_RelatingPort, IfcPort* v6_RelatedPort, IfcElement* v7_RealizingElement); @@ -22624,13 +20026,7 @@ public: /// Reference to a structural activity which is acting upon the specified structural item or element. IfcStructuralActivity* RelatedStructuralActivity() const; void setRelatedStructuralActivity(IfcStructuralActivity* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcStructuralActivityAssignmentSelect; case 5: return Type::IfcStructuralActivity; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingElement"; case 5: return "RelatedStructuralActivity"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelConnectsStructuralActivity (IfcAbstractEntity* e); IfcRelConnectsStructuralActivity (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcStructuralActivityAssignmentSelect* v5_RelatingElement, IfcStructuralActivity* v6_RelatedStructuralActivity); @@ -22643,13 +20039,7 @@ public: void setRelatingElement(IfcElement* v); IfcStructuralMember* RelatedStructuralMember() const; void setRelatedStructuralMember(IfcStructuralMember* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcElement; case 5: return Type::IfcStructuralMember; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingElement"; case 5: return "RelatedStructuralMember"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelConnectsStructuralElement (IfcAbstractEntity* e); IfcRelConnectsStructuralElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingElement, IfcStructuralMember* v6_RelatedStructuralMember); @@ -22707,13 +20097,7 @@ public: /// Defines a coordinate system used for the description of the connection properties in ConnectionCondition relative to the local coordinate system of RelatingStructuralMember. If left unspecified, the placement IfcAxis2Placement3D((x,y,z), ?, ?) is implied with x,y,z being the local member coordinates where the connection is made and the default axes directions being in parallel with the local axes of RelatingStructuralMember. IfcAxis2Placement3D* ConditionCoordinateSystem() const; void setConditionCoordinateSystem(IfcAxis2Placement3D* v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcStructuralMember; case 5: return Type::IfcStructuralConnection; case 6: return Type::IfcBoundaryCondition; case 7: return Type::IfcStructuralConnectionCondition; case 8: return Type::IfcLengthMeasure; case 9: return Type::IfcAxis2Placement3D; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingStructuralMember"; case 5: return "RelatedStructuralConnection"; case 6: return "AppliedCondition"; case 7: return "AdditionalConditions"; case 8: return "SupportedLength"; case 9: return "ConditionCoordinateSystem"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelConnectsStructuralMember (IfcAbstractEntity* e); IfcRelConnectsStructuralMember (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcStructuralMember* v5_RelatingStructuralMember, IfcStructuralConnection* v6_RelatedStructuralConnection, IfcBoundaryCondition* v7_AppliedCondition, IfcStructuralConnectionCondition* v8_AdditionalConditions, boost::optional< double > v9_SupportedLength, IfcAxis2Placement3D* v10_ConditionCoordinateSystem); @@ -22741,13 +20125,7 @@ public: /// The connection constraint explicitly states the eccentricity between a structural member and a structural connection by means of two topological objects (vertex and vertex, or edge and edge, or face and face). IfcConnectionGeometry* ConnectionConstraint() const; void setConnectionConstraint(IfcConnectionGeometry* v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnectsStructuralMember::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcConnectionGeometry; } return IfcRelConnectsStructuralMember::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "ConnectionConstraint"; } return IfcRelConnectsStructuralMember::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelConnectsWithEccentricity (IfcAbstractEntity* e); IfcRelConnectsWithEccentricity (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcStructuralMember* v5_RelatingStructuralMember, IfcStructuralConnection* v6_RelatedStructuralConnection, IfcBoundaryCondition* v7_AppliedCondition, IfcStructuralConnectionCondition* v8_AdditionalConditions, boost::optional< double > v9_SupportedLength, IfcAxis2Placement3D* v10_ConditionCoordinateSystem, IfcConnectionGeometry* v11_ConnectionConstraint); @@ -22786,13 +20164,7 @@ public: /// The type of the connection given for informal purposes, it may include labels, like 'joint', 'rigid joint', 'flexible joint', etc. std::string ConnectionType() const; void setConnectionType(std::string v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_STRING; } return IfcRelConnectsElements::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcElement; case 8: return Type::IfcLabel; } return IfcRelConnectsElements::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "RealizingElements"; case 8: return "ConnectionType"; } return IfcRelConnectsElements::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelConnectsWithRealizingElements (IfcAbstractEntity* e); IfcRelConnectsWithRealizingElements (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcConnectionGeometry* v5_ConnectionGeometry, IfcElement* v6_RelatingElement, IfcElement* v7_RelatedElement, IfcTemplatedEntityList< IfcElement >::ptr v8_RealizingElements, boost::optional< std::string > v9_ConnectionType); @@ -22870,13 +20242,7 @@ public: /// Spatial structure element, within which the element is contained. Any element can only be contained within one element of the project spatial structure. IfcSpatialStructureElement* RelatingStructure() const; void setRelatingStructure(IfcSpatialStructureElement* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcProduct; case 5: return Type::IfcSpatialStructureElement; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatedElements"; case 5: return "RelatingStructure"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelContainedInSpatialStructure (IfcAbstractEntity* e); IfcRelContainedInSpatialStructure (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcProduct >::ptr v5_RelatedElements, IfcSpatialStructureElement* v6_RelatingStructure); @@ -22908,13 +20274,7 @@ public: /// Relationship to the set of coverings at this element. IfcTemplatedEntityList< IfcCovering >::ptr RelatedCoverings() const; void setRelatedCoverings(IfcTemplatedEntityList< IfcCovering >::ptr v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcElement; case 5: return Type::IfcCovering; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingBuildingElement"; case 5: return "RelatedCoverings"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelCoversBldgElements (IfcAbstractEntity* e); IfcRelCoversBldgElements (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingBuildingElement, IfcTemplatedEntityList< IfcCovering >::ptr v6_RelatedCoverings); @@ -22953,13 +20313,7 @@ public: /// Relationship to the set of coverings covering this space. IfcTemplatedEntityList< IfcCovering >::ptr RelatedCoverings() const; void setRelatedCoverings(IfcTemplatedEntityList< IfcCovering >::ptr v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcSpace; case 5: return Type::IfcCovering; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatedSpace"; case 5: return "RelatedCoverings"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelCoversSpaces (IfcAbstractEntity* e); IfcRelCoversSpaces (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpace* v5_RelatedSpace, IfcTemplatedEntityList< IfcCovering >::ptr v6_RelatedCoverings); @@ -23001,13 +20355,7 @@ public: void setRelatingObject(IfcObjectDefinition* v); IfcTemplatedEntityList< IfcObjectDefinition >::ptr RelatedObjects() const; void setRelatedObjects(IfcTemplatedEntityList< IfcObjectDefinition >::ptr v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcObjectDefinition; case 5: return Type::IfcObjectDefinition; } return IfcRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingObject"; case 5: return "RelatedObjects"; } return IfcRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelDecomposes (IfcAbstractEntity* e); IfcRelDecomposes (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcObjectDefinition* v5_RelatingObject, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v6_RelatedObjects); @@ -23044,13 +20392,7 @@ class IfcRelDefines : public IfcRelationship { public: IfcTemplatedEntityList< IfcObject >::ptr RelatedObjects() const; void setRelatedObjects(IfcTemplatedEntityList< IfcObject >::ptr v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcObject; } return IfcRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatedObjects"; } return IfcRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelDefines (IfcAbstractEntity* e); IfcRelDefines (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects); @@ -23076,13 +20418,7 @@ public: /// Reference to the property set definition for that object or set of objects. IfcPropertySetDefinition* RelatingPropertyDefinition() const; void setRelatingPropertyDefinition(IfcPropertySetDefinition* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelDefines::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcPropertySetDefinition; } return IfcRelDefines::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RelatingPropertyDefinition"; } return IfcRelDefines::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelDefinesByProperties (IfcAbstractEntity* e); IfcRelDefinesByProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcPropertySetDefinition* v6_RelatingPropertyDefinition); @@ -23164,13 +20500,7 @@ public: /// Reference to the type (or style) information for that object or set of objects. IfcTypeObject* RelatingType() const; void setRelatingType(IfcTypeObject* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelDefines::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcTypeObject; } return IfcRelDefines::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RelatingType"; } return IfcRelDefines::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelDefinesByType (IfcAbstractEntity* e); IfcRelDefinesByType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcTypeObject* v6_RelatingType); @@ -23195,13 +20525,7 @@ public: /// IFC2x PLATFORM CHANGE: The data type has been changed from IfcBuildingElement to IfcElement with upward compatibility for file based exchange. IfcElement* RelatedBuildingElement() const; void setRelatedBuildingElement(IfcElement* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcOpeningElement; case 5: return Type::IfcElement; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingOpeningElement"; case 5: return "RelatedBuildingElement"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelFillsElement (IfcAbstractEntity* e); IfcRelFillsElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcOpeningElement* v5_RelatingOpeningElement, IfcElement* v6_RelatedBuildingElement); @@ -23222,13 +20546,7 @@ public: /// Relationship to a distribution flow element IfcDistributionFlowElement* RelatingFlowElement() const; void setRelatingFlowElement(IfcDistributionFlowElement* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcDistributionControlElement; case 5: return Type::IfcDistributionFlowElement; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatedControlElements"; case 5: return "RelatingFlowElement"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelFlowControlElements (IfcAbstractEntity* e); IfcRelFlowControlElements (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcDistributionControlElement >::ptr v5_RelatedControlElements, IfcDistributionFlowElement* v6_RelatingFlowElement); @@ -23253,13 +20571,7 @@ public: void setRelatedSpaceProgram(IfcSpaceProgram* v); IfcSpaceProgram* RelatingSpaceProgram() const; void setRelatingSpaceProgram(IfcSpaceProgram* v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_DOUBLE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcCountMeasure; case 5: return Type::IfcNormalisedRatioMeasure; case 6: return Type::IfcSpatialStructureElement; case 7: return Type::IfcSpaceProgram; case 8: return Type::IfcSpaceProgram; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "DailyInteraction"; case 5: return "ImportanceRating"; case 6: return "LocationOfInteraction"; case 7: return "RelatedSpaceProgram"; case 8: return "RelatingSpaceProgram"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelInteractionRequirements (IfcAbstractEntity* e); IfcRelInteractionRequirements (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_DailyInteraction, boost::optional< double > v6_ImportanceRating, IfcSpatialStructureElement* v7_LocationOfInteraction, IfcSpaceProgram* v8_RelatedSpaceProgram, IfcSpaceProgram* v9_RelatingSpaceProgram); @@ -23292,13 +20604,7 @@ public: /// IFC2x4 CHANGE The attributes RelatingObject and RelatedObjects are demoted from the supertype IfcRelDecomposes, and RelatedObjects is refined to be a list. The use of IfcRelNests is repurposed to be a nesting of an ordered collections of parts. class IfcRelNests : public IfcRelDecomposes { public: - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRelDecomposes::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRelDecomposes::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRelDecomposes::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelNests (IfcAbstractEntity* e); IfcRelNests (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcObjectDefinition* v5_RelatingObject, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v6_RelatedObjects); @@ -23307,13 +20613,7 @@ public: class IfcRelOccupiesSpaces : public IfcRelAssignsToActor { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRelAssignsToActor::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRelAssignsToActor::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRelAssignsToActor::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelOccupiesSpaces (IfcAbstractEntity* e); IfcRelOccupiesSpaces (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcActor* v7_RelatingActor, IfcActorRole* v8_ActingRole); @@ -23324,13 +20624,7 @@ class IfcRelOverridesProperties : public IfcRelDefinesByProperties { public: IfcTemplatedEntityList< IfcProperty >::ptr OverridingProperties() const; void setOverridingProperties(IfcTemplatedEntityList< IfcProperty >::ptr v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcRelDefinesByProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcProperty; } return IfcRelDefinesByProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "OverridingProperties"; } return IfcRelDefinesByProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelOverridesProperties (IfcAbstractEntity* e); IfcRelOverridesProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcPropertySetDefinition* v6_RelatingPropertyDefinition, IfcTemplatedEntityList< IfcProperty >::ptr v7_OverridingProperties); @@ -23376,13 +20670,7 @@ public: /// Reference to the IfcFeatureElementAddition that defines an addition to the volume of the element, by using a Boolean addition operation. An example is a projection at the associated element. IfcFeatureElementAddition* RelatedFeatureElement() const; void setRelatedFeatureElement(IfcFeatureElementAddition* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcElement; case 5: return Type::IfcFeatureElementAddition; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingElement"; case 5: return "RelatedFeatureElement"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelProjectsElement (IfcAbstractEntity* e); IfcRelProjectsElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingElement, IfcFeatureElementAddition* v6_RelatedFeatureElement); @@ -23448,13 +20736,7 @@ public: /// IFC2x Edition 4 CHANGE  The attribute relatingStructure as been promoted to the new supertype IfcSpatialElement with upward compatibility for file based exchange. IfcSpatialStructureElement* RelatingStructure() const; void setRelatingStructure(IfcSpatialStructureElement* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcProduct; case 5: return Type::IfcSpatialStructureElement; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatedElements"; case 5: return "RelatingStructure"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelReferencedInSpatialStructure (IfcAbstractEntity* e); IfcRelReferencedInSpatialStructure (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcProduct >::ptr v5_RelatedElements, IfcSpatialStructureElement* v6_RelatingStructure); @@ -23463,13 +20745,7 @@ public: class IfcRelSchedulesCostItems : public IfcRelAssignsToControl { public: - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRelAssignsToControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRelAssignsToControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRelAssignsToControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelSchedulesCostItems (IfcAbstractEntity* e); IfcRelSchedulesCostItems (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl); @@ -23545,13 +20821,7 @@ public: /// The way in which the time lag applies to the sequence. IfcSequenceEnum::IfcSequenceEnum SequenceType() const; void setSequenceType(IfcSequenceEnum::IfcSequenceEnum v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_ENUMERATION; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcProcess; case 5: return Type::IfcProcess; case 6: return Type::IfcTimeMeasure; case 7: return Type::IfcSequenceEnum; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingProcess"; case 5: return "RelatedProcess"; case 6: return "TimeLag"; case 7: return "SequenceType"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelSequence (IfcAbstractEntity* e); IfcRelSequence (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcProcess* v5_RelatingProcess, IfcProcess* v6_RelatedProcess, double v7_TimeLag, IfcSequenceEnum::IfcSequenceEnum v8_SequenceType); @@ -23590,13 +20860,7 @@ public: /// IFC2x Edition 4 CHANGE  The data type has been changed from IfcSpatialStructureElement to IfcSpatialElement with upward compatibility for file based exchange. IfcTemplatedEntityList< IfcSpatialStructureElement >::ptr RelatedBuildings() const; void setRelatedBuildings(IfcTemplatedEntityList< IfcSpatialStructureElement >::ptr v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcSystem; case 5: return Type::IfcSpatialStructureElement; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingSystem"; case 5: return "RelatedBuildings"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelServicesBuildings (IfcAbstractEntity* e); IfcRelServicesBuildings (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSystem* v5_RelatingSystem, IfcTemplatedEntityList< IfcSpatialStructureElement >::ptr v6_RelatedBuildings); @@ -23791,13 +21055,7 @@ public: /// Defines, whether the Space Boundary is internal (Internal), or external, i.e. adjacent to open space (that can be an partially enclosed space, such as terrace (External). IfcInternalOrExternalEnum::IfcInternalOrExternalEnum InternalOrExternalBoundary() const; void setInternalOrExternalBoundary(IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENUMERATION; case 8: return IfcUtil::Argument_ENUMERATION; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcSpace; case 5: return Type::IfcElement; case 6: return Type::IfcConnectionGeometry; case 7: return Type::IfcPhysicalOrVirtualEnum; case 8: return Type::IfcInternalOrExternalEnum; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingSpace"; case 5: return "RelatedBuildingElement"; case 6: return "ConnectionGeometry"; case 7: return "PhysicalOrVirtualBoundary"; case 8: return "InternalOrExternalBoundary"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelSpaceBoundary (IfcAbstractEntity* e); IfcRelSpaceBoundary (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpace* v5_RelatingSpace, IfcElement* v6_RelatedBuildingElement, IfcConnectionGeometry* v7_ConnectionGeometry, IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v8_PhysicalOrVirtualBoundary, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v9_InternalOrExternalBoundary); @@ -23816,13 +21074,7 @@ public: void setRelatingBuildingElement(IfcElement* v); IfcFeatureElementSubtraction* RelatedOpeningElement() const; void setRelatedOpeningElement(IfcFeatureElementSubtraction* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcElement; case 5: return Type::IfcFeatureElementSubtraction; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingBuildingElement"; case 5: return "RelatedOpeningElement"; } return IfcRelConnects::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelVoidsElement (IfcAbstractEntity* e); IfcRelVoidsElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingBuildingElement, IfcFeatureElementSubtraction* v6_RelatedOpeningElement); @@ -23843,14 +21095,8 @@ public: /// IFC2x PLATFORM CHANGE: The attributes BaseUnit and ResourceConsumption have been removed from the abstract entity; they are reintroduced at a lower level in the hierarchy. class IfcResource : public IfcObject { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcObject::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssignsToResource >::ptr ResourceOf() const; // INVERSE IfcRelAssignsToResource::RelatingResource - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelAssignsToResource >::ptr ResourceOf() const; // INVERSE IfcRelAssignsToResource::RelatingResource + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcResource (IfcAbstractEntity* e); IfcResource (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -23940,13 +21186,7 @@ public: /// The angle through which the sweep will be made. This angle is measured from the plane of the swept area provided by the XY plane of the position coordinate system. double Angle() const; void setAngle(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcSweptAreaSolid::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcAxis1Placement; case 3: return Type::IfcPlaneAngleMeasure; } return IfcSweptAreaSolid::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Axis"; case 3: return "Angle"; } return IfcSweptAreaSolid::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRevolvedAreaSolid (IfcAbstractEntity* e); IfcRevolvedAreaSolid (IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcAxis1Placement* v3_Axis, double v4_Angle); @@ -24025,13 +21265,7 @@ public: /// The radius of the cone at the base. double BottomRadius() const; void setBottomRadius(double v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; } return IfcCsgPrimitive3D::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcPositiveLengthMeasure; } return IfcCsgPrimitive3D::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Height"; case 2: return "BottomRadius"; } return IfcCsgPrimitive3D::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRightCircularCone (IfcAbstractEntity* e); IfcRightCircularCone (IfcAxis2Placement3D* v1_Position, double v2_Height, double v3_BottomRadius); @@ -24126,13 +21360,7 @@ public: /// The radius of the cylinder. double Radius() const; void setRadius(double v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; } return IfcCsgPrimitive3D::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcPositiveLengthMeasure; } return IfcCsgPrimitive3D::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Height"; case 2: return "Radius"; } return IfcCsgPrimitive3D::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRightCircularCylinder (IfcAbstractEntity* e); IfcRightCircularCylinder (IfcAxis2Placement3D* v1_Position, double v2_Height, double v3_Radius); @@ -24224,16 +21452,10 @@ public: /// Attribute made optional. IfcElementCompositionEnum::IfcElementCompositionEnum CompositionType() const; void setCompositionType(IfcElementCompositionEnum::IfcElementCompositionEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_ENUMERATION; } return IfcProduct::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcLabel; case 8: return Type::IfcElementCompositionEnum; } return IfcProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "LongName"; case 8: return "CompositionType"; } return IfcProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelReferencedInSpatialStructure >::ptr ReferencesElements() const; // INVERSE IfcRelReferencedInSpatialStructure::RelatingStructure + IfcTemplatedEntityList< IfcRelReferencedInSpatialStructure >::ptr ReferencesElements() const; // INVERSE IfcRelReferencedInSpatialStructure::RelatingStructure IfcTemplatedEntityList< IfcRelServicesBuildings >::ptr ServicedBySystems() const; // INVERSE IfcRelServicesBuildings::RelatedBuildings IfcTemplatedEntityList< IfcRelContainedInSpatialStructure >::ptr ContainsElements() const; // INVERSE IfcRelContainedInSpatialStructure::RelatingStructure - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSpatialStructureElement (IfcAbstractEntity* e); IfcSpatialStructureElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType); @@ -24275,13 +21497,7 @@ public: /// Release IFC2x Edition 3. class IfcSpatialStructureElementType : public IfcElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSpatialStructureElementType (IfcAbstractEntity* e); IfcSpatialStructureElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -24342,13 +21558,7 @@ public: /// The radius of the sphere. double Radius() const; void setRadius(double v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; } return IfcCsgPrimitive3D::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcPositiveLengthMeasure; } return IfcCsgPrimitive3D::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Radius"; } return IfcCsgPrimitive3D::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSphere (IfcAbstractEntity* e); IfcSphere (IfcAxis2Placement3D* v1_Position, double v2_Radius); @@ -24473,14 +21683,8 @@ public: /// as established by subclass-specific geometry use definitions. IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum GlobalOrLocal() const; void setGlobalOrLocal(IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENUMERATION; } return IfcProduct::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcStructuralLoad; case 8: return Type::IfcGlobalOrLocalEnum; } return IfcProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "AppliedLoad"; case 8: return "GlobalOrLocal"; } return IfcProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelConnectsStructuralActivity >::ptr AssignedToStructuralItem() const; // INVERSE IfcRelConnectsStructuralActivity::RelatedStructuralActivity - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelConnectsStructuralActivity >::ptr AssignedToStructuralItem() const; // INVERSE IfcRelConnectsStructuralActivity::RelatedStructuralActivity + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralActivity (IfcAbstractEntity* e); IfcStructuralActivity (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal); @@ -24575,14 +21779,8 @@ public: /// NOTE  A structural item may be grouped into more than one analysis model. In this case, all these models must use the same instance of IfcObjectPlacement. class IfcStructuralItem : public IfcProduct { public: - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcProduct::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelConnectsStructuralActivity >::ptr AssignedStructuralActivity() const; // INVERSE IfcRelConnectsStructuralActivity::RelatingElement - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelConnectsStructuralActivity >::ptr AssignedStructuralActivity() const; // INVERSE IfcRelConnectsStructuralActivity::RelatingElement + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralItem (IfcAbstractEntity* e); IfcStructuralItem (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation); @@ -24594,15 +21792,9 @@ public: /// IFC 2x4 change: Use definitions moved to supertype and subtypes. class IfcStructuralMember : public IfcStructuralItem { public: - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelConnectsStructuralElement >::ptr ReferencesElement() const; // INVERSE IfcRelConnectsStructuralElement::RelatedStructuralMember + IfcTemplatedEntityList< IfcRelConnectsStructuralElement >::ptr ReferencesElement() const; // INVERSE IfcRelConnectsStructuralElement::RelatedStructuralMember IfcTemplatedEntityList< IfcRelConnectsStructuralMember >::ptr ConnectedBy() const; // INVERSE IfcRelConnectsStructuralMember::RelatingStructuralMember - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralMember (IfcAbstractEntity* e); IfcStructuralMember (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation); @@ -24630,14 +21822,8 @@ public: /// IfcStructuralAction. class IfcStructuralReaction : public IfcStructuralActivity { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralActivity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralActivity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralActivity::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcStructuralAction >::ptr Causes() const; // INVERSE IfcStructuralAction::CausedBy - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcStructuralAction >::ptr Causes() const; // INVERSE IfcStructuralAction::CausedBy + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralReaction (IfcAbstractEntity* e); IfcStructuralReaction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal); @@ -24673,13 +21859,7 @@ public: /// Defines the typically understood thickness of the structural surface member, measured normal to its reference surface. double Thickness() const; void setThickness(double v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_ENUMERATION; case 8: return IfcUtil::Argument_DOUBLE; } return IfcStructuralMember::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcStructuralSurfaceTypeEnum; case 8: return Type::IfcPositiveLengthMeasure; } return IfcStructuralMember::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "PredefinedType"; case 8: return "Thickness"; } return IfcStructuralMember::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralSurfaceMember (IfcAbstractEntity* e); IfcStructuralSurfaceMember (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum v8_PredefinedType, boost::optional< double > v9_Thickness); @@ -24709,13 +21889,7 @@ public: void setSubsequentThickness(std::vector< double > /*[2:?]*/ v); IfcShapeAspect* VaryingThicknessLocation() const; void setVaryingThicknessLocation(IfcShapeAspect* v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; case 10: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcStructuralSurfaceMember::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcPositiveLengthMeasure; case 10: return Type::IfcShapeAspect; } return IfcStructuralSurfaceMember::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "SubsequentThickness"; case 10: return "VaryingThicknessLocation"; } return IfcStructuralSurfaceMember::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralSurfaceMemberVarying (IfcAbstractEntity* e); IfcStructuralSurfaceMemberVarying (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum v8_PredefinedType, boost::optional< double > v9_Thickness, std::vector< double > /*[2:?]*/ v10_SubsequentThickness, IfcShapeAspect* v11_VaryingThicknessLocation); @@ -24724,13 +21898,7 @@ public: class IfcStructuredDimensionCallout : public IfcDraughtingCallout { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDraughtingCallout::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDraughtingCallout::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDraughtingCallout::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuredDimensionCallout (IfcAbstractEntity* e); IfcStructuredDimensionCallout (IfcEntityList::ptr v1_Contents); @@ -24816,13 +21984,7 @@ public: /// The surface containing the Directrix. IfcSurface* ReferenceSurface() const; void setReferenceSurface(IfcSurface* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSweptAreaSolid::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcCurve; case 3: return Type::IfcParameterValue; case 4: return Type::IfcParameterValue; case 5: return Type::IfcSurface; } return IfcSweptAreaSolid::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Directrix"; case 3: return "StartParam"; case 4: return "EndParam"; case 5: return "ReferenceSurface"; } return IfcSweptAreaSolid::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceCurveSweptAreaSolid (IfcAbstractEntity* e); IfcSurfaceCurveSweptAreaSolid (IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcCurve* v3_Directrix, double v4_StartParam, double v5_EndParam, IfcSurface* v6_ReferenceSurface); @@ -24849,13 +22011,7 @@ public: /// The depth of the extrusion, it determines the parameterization. double Depth() const; void setDepth(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcSweptSurface::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcDirection; case 3: return Type::IfcLengthMeasure; } return IfcSweptSurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "ExtrudedDirection"; case 3: return "Depth"; } return IfcSweptSurface::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceOfLinearExtrusion (IfcAbstractEntity* e); IfcSurfaceOfLinearExtrusion (IfcProfileDef* v1_SweptCurve, IfcAxis2Placement3D* v2_Position, IfcDirection* v3_ExtrudedDirection, double v4_Depth); @@ -24883,13 +22039,7 @@ public: /// A point on the axis of revolution and the direction of the axis of revolution. IfcAxis1Placement* AxisPosition() const; void setAxisPosition(IfcAxis1Placement* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSweptSurface::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcAxis1Placement; } return IfcSweptSurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "AxisPosition"; } return IfcSweptSurface::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceOfRevolution (IfcAbstractEntity* e); IfcSurfaceOfRevolution (IfcProfileDef* v1_SweptCurve, IfcAxis2Placement3D* v2_Position, IfcAxis1Placement* v3_AxisPosition); @@ -24927,13 +22077,7 @@ public: /// 'Panel': Panels such as glass. class IfcSystemFurnitureElementType : public IfcFurnishingElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcFurnishingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcFurnishingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcFurnishingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSystemFurnitureElementType (IfcAbstractEntity* e); IfcSystemFurnitureElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -25222,13 +22366,7 @@ public: /// comparison to the priorities of other tasks). int Priority() const; void setPriority(int v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_BOOL; case 9: return IfcUtil::Argument_INT; } return IfcProcess::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; case 6: return Type::IfcLabel; case 7: return Type::IfcLabel; case 8: return Type::UNDEFINED; case 9: return Type::UNDEFINED; } return IfcProcess::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "TaskId"; case 6: return "Status"; case 7: return "WorkMethod"; case 8: return "IsMilestone"; case 9: return "Priority"; } return IfcProcess::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTask (IfcAbstractEntity* e); IfcTask (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority); @@ -25302,13 +22440,7 @@ public: /// Predefined types to define the particular type of the transport element. There may be property set definitions available for each predefined type. IfcTransportElementTypeEnum::IfcTransportElementTypeEnum PredefinedType() const; void setPredefinedType(IfcTransportElementTypeEnum::IfcTransportElementTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcTransportElementTypeEnum; } return IfcElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTransportElementType (IfcAbstractEntity* e); IfcTransportElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTransportElementTypeEnum::IfcTransportElementTypeEnum v10_PredefinedType); @@ -25334,14 +22466,8 @@ public: /// Information about the actor. IfcActorSelect* TheActor() const; void setTheActor(IfcActorSelect* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcActorSelect; } return IfcObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "TheActor"; } return IfcObject::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssignsToActor >::ptr IsActingUpon() const; // INVERSE IfcRelAssignsToActor::RelatingActor - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelAssignsToActor >::ptr IsActingUpon() const; // INVERSE IfcRelAssignsToActor::RelatingActor + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcActor (IfcAbstractEntity* e); IfcActor (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcActorSelect* v6_TheActor); @@ -25522,14 +22648,8 @@ public: /// RepresentationType : 'GeometricSet' class IfcAnnotation : public IfcProduct { public: - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcProduct::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelContainedInSpatialStructure >::ptr ContainedInStructure() const; // INVERSE IfcRelContainedInSpatialStructure::RelatedElements - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelContainedInSpatialStructure >::ptr ContainedInStructure() const; // INVERSE IfcRelContainedInSpatialStructure::RelatedElements + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAnnotation (IfcAbstractEntity* e); IfcAnnotation (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation); @@ -25591,13 +22711,7 @@ public: bool hasCentreOfGravityInY() const; double CentreOfGravityInY() const; void setCentreOfGravityInY(double v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; } return IfcIShapeProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcPositiveLengthMeasure; case 9: return Type::IfcPositiveLengthMeasure; case 10: return Type::IfcPositiveLengthMeasure; case 11: return Type::IfcPositiveLengthMeasure; } return IfcIShapeProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "TopFlangeWidth"; case 9: return "TopFlangeThickness"; case 10: return "TopFlangeFilletRadius"; case 11: return "CentreOfGravityInY"; } return IfcIShapeProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAsymmetricIShapeProfileDef (IfcAbstractEntity* e); IfcAsymmetricIShapeProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_OverallWidth, double v5_OverallDepth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, double v9_TopFlangeWidth, boost::optional< double > v10_TopFlangeThickness, boost::optional< double > v11_TopFlangeFilletRadius, boost::optional< double > v12_CentreOfGravityInY); @@ -25711,13 +22825,7 @@ public: /// The size of the block along the placement Z axis. It is provided by the inherited axis placement through SELF\IfcCsgPrimitive3D.Position.P[3]. double ZLength() const; void setZLength(double v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcCsgPrimitive3D::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcPositiveLengthMeasure; case 3: return Type::IfcPositiveLengthMeasure; } return IfcCsgPrimitive3D::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "XLength"; case 2: return "YLength"; case 3: return "ZLength"; } return IfcCsgPrimitive3D::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBlock (IfcAbstractEntity* e); IfcBlock (IfcAxis2Placement3D* v1_Position, double v2_XLength, double v3_YLength, double v4_ZLength); @@ -25732,13 +22840,7 @@ public: /// HISTORY New entity in IFC Release 2.x. class IfcBooleanClippingResult : public IfcBooleanResult { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBooleanResult::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBooleanResult::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBooleanResult::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBooleanClippingResult (IfcAbstractEntity* e); IfcBooleanClippingResult (IfcBooleanOperator::IfcBooleanOperator v1_Operator, IfcBooleanOperand* v2_FirstOperand, IfcBooleanOperand* v3_SecondOperand); @@ -25756,13 +22858,7 @@ public: /// A bounded curve has a start point and an end point. class IfcBoundedCurve : public IfcCurve { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoundedCurve (IfcAbstractEntity* e); IfcBoundedCurve (); @@ -25960,13 +23056,7 @@ public: /// Address given to the building for postal purposes. IfcPostalAddress* BuildingAddress() const; void setBuildingAddress(IfcPostalAddress* v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSpatialStructureElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcLengthMeasure; case 10: return Type::IfcLengthMeasure; case 11: return Type::IfcPostalAddress; } return IfcSpatialStructureElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "ElevationOfRefHeight"; case 10: return "ElevationOfTerrain"; case 11: return "BuildingAddress"; } return IfcSpatialStructureElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBuilding (IfcAbstractEntity* e); IfcBuilding (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, boost::optional< double > v10_ElevationOfRefHeight, boost::optional< double > v11_ElevationOfTerrain, IfcPostalAddress* v12_BuildingAddress); @@ -26003,13 +23093,7 @@ public: /// Release IFC2x Edition 2. class IfcBuildingElementType : public IfcElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBuildingElementType (IfcAbstractEntity* e); IfcBuildingElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -26199,13 +23283,7 @@ public: /// Elevation of the base of this storey, relative to the 0,00 internal reference height of the building. The 0.00 level is given by the absolute above sea level height by the ElevationOfRefHeight attribute given at IfcBuilding. double Elevation() const; void setElevation(double v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_DOUBLE; } return IfcSpatialStructureElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcLengthMeasure; } return IfcSpatialStructureElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "Elevation"; } return IfcSpatialStructureElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBuildingStorey (IfcAbstractEntity* e); IfcBuildingStorey (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, boost::optional< double > v10_Elevation); @@ -26234,13 +23312,7 @@ public: /// Thickness of the material, it is the difference between the outer and inner radius. double WallThickness() const; void setWallThickness(double v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_DOUBLE; } return IfcCircleProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPositiveLengthMeasure; } return IfcCircleProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "WallThickness"; } return IfcCircleProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCircleHollowProfileDef (IfcAbstractEntity* e); IfcCircleHollowProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_Radius, double v5_WallThickness); @@ -26349,13 +23421,7 @@ public: /// Identifies the predefined types of a column element from which the type required may be set. IfcColumnTypeEnum::IfcColumnTypeEnum PredefinedType() const; void setPredefinedType(IfcColumnTypeEnum::IfcColumnTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcColumnTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcColumnType (IfcAbstractEntity* e); IfcColumnType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcColumnTypeEnum::IfcColumnTypeEnum v10_PredefinedType); @@ -26435,13 +23501,7 @@ public: /// Indication of whether the curve intersects itself or not; this is for information only. bool SelfIntersect() const; void setSelfIntersect(bool v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_BOOL; } return IfcBoundedCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCompositeCurveSegment; case 1: return Type::UNDEFINED; } return IfcBoundedCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Segments"; case 1: return "SelfIntersect"; } return IfcBoundedCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCompositeCurve (IfcAbstractEntity* e); IfcCompositeCurve (IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect); @@ -26457,13 +23517,7 @@ public: /// The location and orientation of the conic. Further details of the interpretation of this attribute are given for the individual subtypes." IfcAxis2Placement* Position() const; void setPosition(IfcAxis2Placement* v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAxis2Placement; } return IfcCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Position"; } return IfcCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConic (IfcAbstractEntity* e); IfcConic (IfcAxis2Placement* v1_Position); @@ -26560,13 +23614,7 @@ public: bool hasBaseQuantity() const; IfcMeasureWithUnit* BaseQuantity() const; void setBaseQuantity(IfcMeasureWithUnit* v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENUMERATION; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; case 6: return Type::IfcLabel; case 7: return Type::IfcResourceConsumptionEnum; case 8: return Type::IfcMeasureWithUnit; } return IfcResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "ResourceIdentifier"; case 6: return "ResourceGroup"; case 7: return "ResourceConsumption"; case 8: return "BaseQuantity"; } return IfcResource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstructionResource (IfcAbstractEntity* e); IfcConstructionResource (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity); @@ -26584,14 +23632,8 @@ public: /// Controls have assignments from products, processes, or other objects by using the relationship object IfcRelAssignsToControl. class IfcControl : public IfcObject { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcObject::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssignsToControl >::ptr Controls() const; // INVERSE IfcRelAssignsToControl::RelatingControl - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelAssignsToControl >::ptr Controls() const; // INVERSE IfcRelAssignsToControl::RelatingControl + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcControl (IfcAbstractEntity* e); IfcControl (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -26635,13 +23677,7 @@ public: /// Figure 168 — Cost assignment class IfcCostItem : public IfcControl { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCostItem (IfcAbstractEntity* e); IfcCostItem (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -26716,13 +23752,7 @@ public: /// IFC2x4 CHANGE The attribute has been made optional. IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum PredefinedType() const; void setPredefinedType(IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum v); - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_STRING; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_ENTITY_INSTANCE; case 11: return IfcUtil::Argument_STRING; case 12: return IfcUtil::Argument_ENUMERATION; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcActorSelect; case 6: return Type::IfcActorSelect; case 7: return Type::IfcDateTimeSelect; case 8: return Type::IfcLabel; case 9: return Type::IfcActorSelect; case 10: return Type::IfcDateTimeSelect; case 11: return Type::IfcIdentifier; case 12: return Type::IfcCostScheduleTypeEnum; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "SubmittedBy"; case 6: return "PreparedBy"; case 7: return "SubmittedOn"; case 8: return "Status"; case 9: return "TargetUsers"; case 10: return "UpdateDate"; case 11: return "ID"; case 12: return "PredefinedType"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCostSchedule (IfcAbstractEntity* e); IfcCostSchedule (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcActorSelect* v6_SubmittedBy, IfcActorSelect* v7_PreparedBy, IfcDateTimeSelect* v8_SubmittedOn, boost::optional< std::string > v9_Status, boost::optional< IfcEntityList::ptr > v10_TargetUsers, IfcDateTimeSelect* v11_UpdateDate, std::string v12_ID, IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum v13_PredefinedType); @@ -26812,13 +23842,7 @@ public: /// Predefined types to define the particular type of the covering. There may be property set definitions available for each predefined type. IfcCoveringTypeEnum::IfcCoveringTypeEnum PredefinedType() const; void setPredefinedType(IfcCoveringTypeEnum::IfcCoveringTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcCoveringTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCoveringType (IfcAbstractEntity* e); IfcCoveringType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCoveringTypeEnum::IfcCoveringTypeEnum v10_PredefinedType); @@ -26836,13 +23860,7 @@ public: /// IfcCrewResource defines the occurrence of any crew resource; common information about crew resource types is handled by IfcCrewResourceType. The IfcCrewResourceType (if present) may establish the common type name, common properties, and common productivities for various task types using IfcRelAssignsToProcess. The IfcCrewResourceType is attached using the IfcRelDefinesByType.RelatingType objectified relationship and is accessible by the inverse IsTypedBy attribute. class IfcCrewResource : public IfcConstructionResource { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcConstructionResource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCrewResource (IfcAbstractEntity* e); IfcCrewResource (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity); @@ -26874,13 +23892,7 @@ public: /// Identifies the predefined types of a curtain wall element from which the type required may be set. IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum PredefinedType() const; void setPredefinedType(IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcCurtainWallTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCurtainWallType (IfcAbstractEntity* e); IfcCurtainWallType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum v10_PredefinedType); @@ -26889,13 +23901,7 @@ public: class IfcDimensionCurveDirectedCallout : public IfcDraughtingCallout { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDraughtingCallout::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDraughtingCallout::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDraughtingCallout::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDimensionCurveDirectedCallout (IfcAbstractEntity* e); IfcDimensionCurveDirectedCallout (IfcEntityList::ptr v1_Contents); @@ -26931,13 +23937,7 @@ public: /// IFC2x4. class IfcDistributionElementType : public IfcElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDistributionElementType (IfcAbstractEntity* e); IfcDistributionElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -27010,13 +24010,7 @@ public: /// NOTE: The product representations are defined as representation maps (at the level of the supertype IfcTypeProduct, which get assigned by an element occurrence instance through the IfcShapeRepresentation.Item[1] being an IfcMappedItem. class IfcDistributionFlowElementType : public IfcDistributionElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDistributionFlowElementType (IfcAbstractEntity* e); IfcDistributionFlowElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -27051,13 +24045,7 @@ public: void setRatedPowerInput(double v); int InputPhase() const; void setInputPhase(int v); - virtual unsigned int getArgumentCount() const { return 14; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_ENUMERATION; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_DOUBLE; case 13: return IfcUtil::Argument_INT; } return IfcEnergyProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcElectricCurrentEnum; case 7: return Type::IfcElectricVoltageMeasure; case 8: return Type::IfcFrequencyMeasure; case 9: return Type::IfcElectricCurrentMeasure; case 10: return Type::IfcElectricCurrentMeasure; case 11: return Type::IfcPowerMeasure; case 12: return Type::IfcPowerMeasure; case 13: return Type::UNDEFINED; } return IfcEnergyProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "ElectricCurrentType"; case 7: return "InputVoltage"; case 8: return "InputFrequency"; case 9: return "FullLoadCurrent"; case 10: return "MinimumCircuitCurrent"; case 11: return "MaximumPowerInput"; case 12: return "RatedPowerInput"; case 13: return "InputPhase"; } return IfcEnergyProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricalBaseProperties (IfcAbstractEntity* e); IfcElectricalBaseProperties (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcEnergySequenceEnum::IfcEnergySequenceEnum > v5_EnergySequence, boost::optional< std::string > v6_UserDefinedEnergySequence, boost::optional< IfcElectricCurrentEnum::IfcElectricCurrentEnum > v7_ElectricCurrentType, double v8_InputVoltage, double v9_InputFrequency, boost::optional< double > v10_FullLoadCurrent, boost::optional< double > v11_MinimumCircuitCurrent, boost::optional< double > v12_MaximumPowerInput, boost::optional< double > v13_RatedPowerInput, int v14_InputPhase); @@ -27123,12 +24111,7 @@ public: /// The tag (or label) identifier at the particular instance of a product, e.g. the serial number, or the position number. It is the identifier at the occurrence level. std::string Tag() const; void setTag(std::string v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_STRING; } return IfcProduct::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcIdentifier; } return IfcProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "Tag"; } return IfcProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelConnectsStructuralElement >::ptr HasStructuralMember() const; // INVERSE IfcRelConnectsStructuralElement::RelatingElement + IfcTemplatedEntityList< IfcRelConnectsStructuralElement >::ptr HasStructuralMember() const; // INVERSE IfcRelConnectsStructuralElement::RelatingElement IfcTemplatedEntityList< IfcRelFillsElement >::ptr FillsVoids() const; // INVERSE IfcRelFillsElement::RelatedBuildingElement IfcTemplatedEntityList< IfcRelConnectsElements >::ptr ConnectedTo() const; // INVERSE IfcRelConnectsElements::RelatingElement IfcTemplatedEntityList< IfcRelCoversBldgElements >::ptr HasCoverings() const; // INVERSE IfcRelCoversBldgElements::RelatingBuildingElement @@ -27140,8 +24123,7 @@ public: IfcTemplatedEntityList< IfcRelSpaceBoundary >::ptr ProvidesBoundaries() const; // INVERSE IfcRelSpaceBoundary::RelatedBuildingElement IfcTemplatedEntityList< IfcRelConnectsElements >::ptr ConnectedFrom() const; // INVERSE IfcRelConnectsElements::RelatedElement IfcTemplatedEntityList< IfcRelContainedInSpatialStructure >::ptr ContainedInStructure() const; // INVERSE IfcRelContainedInSpatialStructure::RelatedElements - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElement (IfcAbstractEntity* e); IfcElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -27253,13 +24235,7 @@ public: /// IFC2x4 CHANGE  The attribute has been changed to be optional. IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum PredefinedType() const; void setPredefinedType(IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_ENUMERATION; } return IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcAssemblyPlaceEnum; case 9: return Type::IfcElementAssemblyTypeEnum; } return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "AssemblyPlace"; case 9: return "PredefinedType"; } return IfcElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElementAssembly (IfcAbstractEntity* e); IfcElementAssembly (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum > v9_AssemblyPlace, IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum v10_PredefinedType); @@ -27344,13 +24320,7 @@ public: /// element components in the IfcElementQuantity. class IfcElementComponent : public IfcElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElementComponent (IfcAbstractEntity* e); IfcElementComponent (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -27367,13 +24337,7 @@ public: /// Release 2x2 class IfcElementComponentType : public IfcElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElementComponentType (IfcAbstractEntity* e); IfcElementComponentType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -27414,13 +24378,7 @@ public: /// The second radius of the ellipse which shall be positive. double SemiAxis2() const; void setSemiAxis2(double v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; case 2: return IfcUtil::Argument_DOUBLE; } return IfcConic::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcPositiveLengthMeasure; case 2: return Type::IfcPositiveLengthMeasure; } return IfcConic::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "SemiAxis1"; case 2: return "SemiAxis2"; } return IfcConic::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEllipse (IfcAbstractEntity* e); IfcEllipse (IfcAxis2Placement* v1_Position, double v2_SemiAxis1, double v3_SemiAxis2); @@ -27453,13 +24411,7 @@ public: /// HISTORY: New entity in IFC Release 2x2. class IfcEnergyConversionDeviceType : public IfcDistributionFlowElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEnergyConversionDeviceType (IfcAbstractEntity* e); IfcEnergyConversionDeviceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -27468,13 +24420,7 @@ public: class IfcEquipmentElement : public IfcElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEquipmentElement (IfcAbstractEntity* e); IfcEquipmentElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -27483,13 +24429,7 @@ public: class IfcEquipmentStandard : public IfcControl { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEquipmentStandard (IfcAbstractEntity* e); IfcEquipmentStandard (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -27526,13 +24466,7 @@ public: /// Defines the type of evaporative cooler. IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum PredefinedType() const; void setPredefinedType(IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcEvaporativeCoolerTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEvaporativeCoolerType (IfcAbstractEntity* e); IfcEvaporativeCoolerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum v10_PredefinedType); @@ -27569,13 +24503,7 @@ public: /// Defines the type of evaporator. IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum PredefinedType() const; void setPredefinedType(IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcEvaporatorTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEvaporatorType (IfcAbstractEntity* e); IfcEvaporatorType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum v10_PredefinedType); @@ -27607,13 +24535,7 @@ public: /// Figure 257 — Faceted B-rep class IfcFacetedBrep : public IfcManifoldSolidBrep { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcManifoldSolidBrep::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcManifoldSolidBrep::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcManifoldSolidBrep::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFacetedBrep (IfcAbstractEntity* e); IfcFacetedBrep (IfcClosedShell* v1_Outer); @@ -27648,13 +24570,7 @@ public: /// Set of closed shells defining voids within the solid. IfcTemplatedEntityList< IfcClosedShell >::ptr Voids() const; void setVoids(IfcTemplatedEntityList< IfcClosedShell >::ptr v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcManifoldSolidBrep::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcClosedShell; } return IfcManifoldSolidBrep::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Voids"; } return IfcManifoldSolidBrep::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFacetedBrepWithVoids (IfcAbstractEntity* e); IfcFacetedBrepWithVoids (IfcClosedShell* v1_Outer, IfcTemplatedEntityList< IfcClosedShell >::ptr v2_Voids); @@ -27670,13 +24586,7 @@ public: /// Attribute PredefinedType added. class IfcFastener : public IfcElementComponent { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElementComponent::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElementComponent::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElementComponent::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFastener (IfcAbstractEntity* e); IfcFastener (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -27707,13 +24617,7 @@ public: /// Pset_FastenerWeld (WELD) class IfcFastenerType : public IfcElementComponentType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElementComponentType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElementComponentType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElementComponentType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFastenerType (IfcAbstractEntity* e); IfcFastenerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -27815,13 +24719,7 @@ public: /// complex shape. class IfcFeatureElement : public IfcElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFeatureElement (IfcAbstractEntity* e); IfcFeatureElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -27884,14 +24782,8 @@ public: /// level of its subtypes. class IfcFeatureElementAddition : public IfcFeatureElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcFeatureElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcFeatureElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcFeatureElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelProjectsElement >::ptr ProjectsElements() const; // INVERSE IfcRelProjectsElement::RelatedFeatureElement - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelProjectsElement >::ptr ProjectsElements() const; // INVERSE IfcRelProjectsElement::RelatedFeatureElement + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFeatureElementAddition (IfcAbstractEntity* e); IfcFeatureElementAddition (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -27949,14 +24841,8 @@ public: /// subtypes. class IfcFeatureElementSubtraction : public IfcFeatureElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcFeatureElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcFeatureElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcFeatureElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelVoidsElement >::ptr VoidsElements() const; // INVERSE IfcRelVoidsElement::RelatedOpeningElement - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelVoidsElement >::ptr VoidsElements() const; // INVERSE IfcRelVoidsElement::RelatedOpeningElement + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFeatureElementSubtraction (IfcAbstractEntity* e); IfcFeatureElementSubtraction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -27988,13 +24874,7 @@ public: /// HISTORY: New entity in IFC Release 2x2. class IfcFlowControllerType : public IfcDistributionFlowElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowControllerType (IfcAbstractEntity* e); IfcFlowControllerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -28027,13 +24907,7 @@ public: /// HISTORY: New entity in IFC Release 2x2. class IfcFlowFittingType : public IfcDistributionFlowElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowFittingType (IfcAbstractEntity* e); IfcFlowFittingType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -28076,13 +24950,7 @@ public: /// Defines the type of flow meter. IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum PredefinedType() const; void setPredefinedType(IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowControllerType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcFlowMeterTypeEnum; } return IfcFlowControllerType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowControllerType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowMeterType (IfcAbstractEntity* e); IfcFlowMeterType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum v10_PredefinedType); @@ -28113,13 +24981,7 @@ public: /// HISTORY: New entity in IFC Release 2x2. class IfcFlowMovingDeviceType : public IfcDistributionFlowElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowMovingDeviceType (IfcAbstractEntity* e); IfcFlowMovingDeviceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -28159,13 +25021,7 @@ public: /// IfcMaterial : For elements comprised of a single material where profiles are not applicable, this indicates the material. class IfcFlowSegmentType : public IfcDistributionFlowElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowSegmentType (IfcAbstractEntity* e); IfcFlowSegmentType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -28180,13 +25036,7 @@ public: /// HISTORY: New entity in IFC Release 2x2. class IfcFlowStorageDeviceType : public IfcDistributionFlowElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowStorageDeviceType (IfcAbstractEntity* e); IfcFlowStorageDeviceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -28201,13 +25051,7 @@ public: /// HISTORY: New entity in IFC Release 2x2. class IfcFlowTerminalType : public IfcDistributionFlowElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowTerminalType (IfcAbstractEntity* e); IfcFlowTerminalType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -28224,13 +25068,7 @@ public: /// HISTORY: New entity in IFC Release 2x2. class IfcFlowTreatmentDeviceType : public IfcDistributionFlowElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowTreatmentDeviceType (IfcAbstractEntity* e); IfcFlowTreatmentDeviceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -28342,13 +25180,7 @@ public: /// 'MappedRepresentation' class IfcFurnishingElement : public IfcElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFurnishingElement (IfcAbstractEntity* e); IfcFurnishingElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -28357,13 +25189,7 @@ public: class IfcFurnitureStandard : public IfcControl { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFurnitureStandard (IfcAbstractEntity* e); IfcFurnitureStandard (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -28374,13 +25200,7 @@ class IfcGasTerminalType : public IfcFlowTerminalType { public: IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum PredefinedType() const; void setPredefinedType(IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcGasTerminalTypeEnum; } return IfcFlowTerminalType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTerminalType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGasTerminalType (IfcAbstractEntity* e); IfcGasTerminalType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum v10_PredefinedType); @@ -28495,14 +25315,8 @@ public: /// List of grid axes defining the third row of grid lines. It may be given in the case of a triangular grid. IfcTemplatedEntityList< IfcGridAxis >::ptr WAxes() const; void setWAxes(IfcTemplatedEntityList< IfcGridAxis >::ptr v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcProduct::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcGridAxis; case 8: return Type::IfcGridAxis; case 9: return Type::IfcGridAxis; } return IfcProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "UAxes"; case 8: return "VAxes"; case 9: return "WAxes"; } return IfcProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelContainedInSpatialStructure >::ptr ContainedInStructure() const; // INVERSE IfcRelContainedInSpatialStructure::RelatedElements - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelContainedInSpatialStructure >::ptr ContainedInStructure() const; // INVERSE IfcRelContainedInSpatialStructure::RelatedElements + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGrid (IfcAbstractEntity* e); IfcGrid (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcTemplatedEntityList< IfcGridAxis >::ptr v8_UAxes, IfcTemplatedEntityList< IfcGridAxis >::ptr v9_VAxes, boost::optional< IfcTemplatedEntityList< IfcGridAxis >::ptr > v10_WAxes); @@ -28540,14 +25354,8 @@ public: /// Controls: affecting the group using IfcRelAssignsToControl class IfcGroup : public IfcObject { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcObject::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssignsToGroup >::ptr IsGroupedBy() const; // INVERSE IfcRelAssignsToGroup::RelatingGroup - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelAssignsToGroup >::ptr IsGroupedBy() const; // INVERSE IfcRelAssignsToGroup::RelatingGroup + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcGroup (IfcAbstractEntity* e); IfcGroup (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -28587,13 +25395,7 @@ public: /// Defines the basic types of heat exchanger (e.g., plate, shell and tube, etc.). IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum PredefinedType() const; void setPredefinedType(IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcHeatExchangerTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcHeatExchangerType (IfcAbstractEntity* e); IfcHeatExchangerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum v10_PredefinedType); @@ -28630,13 +25432,7 @@ public: /// Defines the type of humidifier. IfcHumidifierTypeEnum::IfcHumidifierTypeEnum PredefinedType() const; void setPredefinedType(IfcHumidifierTypeEnum::IfcHumidifierTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcHumidifierTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcHumidifierType (IfcAbstractEntity* e); IfcHumidifierType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcHumidifierTypeEnum::IfcHumidifierTypeEnum v10_PredefinedType); @@ -28678,13 +25474,7 @@ public: /// An estimate of the original cost value of the inventory. IfcCostValue* OriginalValue() const; void setOriginalValue(IfcCostValue* v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcGroup::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcInventoryTypeEnum; case 6: return Type::IfcActorSelect; case 7: return Type::IfcPerson; case 8: return Type::IfcCalendarDate; case 9: return Type::IfcCostValue; case 10: return Type::IfcCostValue; } return IfcGroup::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "InventoryType"; case 6: return "Jurisdiction"; case 7: return "ResponsiblePersons"; case 8: return "LastUpdateDate"; case 9: return "CurrentValue"; case 10: return "OriginalValue"; } return IfcGroup::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcInventory (IfcAbstractEntity* e); IfcInventory (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcInventoryTypeEnum::IfcInventoryTypeEnum v6_InventoryType, IfcActorSelect* v7_Jurisdiction, IfcTemplatedEntityList< IfcPerson >::ptr v8_ResponsiblePersons, IfcCalendarDate* v9_LastUpdateDate, IfcCostValue* v10_CurrentValue, IfcCostValue* v11_OriginalValue); @@ -28722,13 +25512,7 @@ public: /// Identifies the predefined types of junction boxes from which the type required may be set. IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum PredefinedType() const; void setPredefinedType(IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowFittingType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcJunctionBoxTypeEnum; } return IfcFlowFittingType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowFittingType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcJunctionBoxType (IfcAbstractEntity* e); IfcJunctionBoxType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum v10_PredefinedType); @@ -28764,13 +25548,7 @@ public: bool hasSkillSet() const; std::string SkillSet() const; void setSkillSet(std::string v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_STRING; } return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcText; } return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "SkillSet"; } return IfcConstructionResource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLaborResource (IfcAbstractEntity* e); IfcLaborResource (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity, boost::optional< std::string > v10_SkillSet); @@ -28810,13 +25588,7 @@ public: /// Identifies the predefined types of lamp from which the type required may be set. IfcLampTypeEnum::IfcLampTypeEnum PredefinedType() const; void setPredefinedType(IfcLampTypeEnum::IfcLampTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcLampTypeEnum; } return IfcFlowTerminalType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTerminalType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLampType (IfcAbstractEntity* e); IfcLampType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcLampTypeEnum::IfcLampTypeEnum v10_PredefinedType); @@ -28858,13 +25630,7 @@ public: /// Identifies the predefined types of light fixture from which the type required may be set. IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum PredefinedType() const; void setPredefinedType(IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcLightFixtureTypeEnum; } return IfcFlowTerminalType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTerminalType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLightFixtureType (IfcAbstractEntity* e); IfcLightFixtureType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum v10_PredefinedType); @@ -28873,13 +25639,7 @@ public: class IfcLinearDimension : public IfcDimensionCurveDirectedCallout { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLinearDimension (IfcAbstractEntity* e); IfcLinearDimension (IfcEntityList::ptr v1_Contents); @@ -28924,13 +25684,7 @@ public: bool hasNominalLength() const; double NominalLength() const; void setNominalLength(double v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; } return IfcFastener::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcPositiveLengthMeasure; case 9: return Type::IfcPositiveLengthMeasure; } return IfcFastener::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "NominalDiameter"; case 9: return "NominalLength"; } return IfcFastener::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMechanicalFastener (IfcAbstractEntity* e); IfcMechanicalFastener (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_NominalDiameter, boost::optional< double > v10_NominalLength); @@ -28973,13 +25727,7 @@ public: /// Pset_MechanicalFastenerBolt (BOLT) class IfcMechanicalFastenerType : public IfcFastenerType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcFastenerType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcFastenerType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcFastenerType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMechanicalFastenerType (IfcAbstractEntity* e); IfcMechanicalFastenerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -29091,13 +25839,7 @@ public: /// Identifies the predefined types of a linear structural member element from which the type required may be set. IfcMemberTypeEnum::IfcMemberTypeEnum PredefinedType() const; void setPredefinedType(IfcMemberTypeEnum::IfcMemberTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcMemberTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMemberType (IfcAbstractEntity* e); IfcMemberType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcMemberTypeEnum::IfcMemberTypeEnum v10_PredefinedType); @@ -29135,13 +25877,7 @@ public: /// Identifies the predefined types of motor connection from which the type required may be set. IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum PredefinedType() const; void setPredefinedType(IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcMotorConnectionTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMotorConnectionType (IfcAbstractEntity* e); IfcMotorConnectionType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum v10_PredefinedType); @@ -29158,13 +25894,7 @@ public: bool hasPunchList() const; std::vector< std::string > /*[1:?]*/ PunchList() const; void setPunchList(std::vector< std::string > /*[1:?]*/ v); - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_ENTITY_INSTANCE; case 11: return IfcUtil::Argument_ENTITY_INSTANCE; case 12: return IfcUtil::Argument_AGGREGATE_OF_STRING; } return IfcTask::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcSpatialStructureElement; case 11: return Type::IfcSpatialStructureElement; case 12: return Type::IfcText; } return IfcTask::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "MoveFrom"; case 11: return "MoveTo"; case 12: return "PunchList"; } return IfcTask::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMove (IfcAbstractEntity* e); IfcMove (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority, IfcSpatialStructureElement* v11_MoveFrom, IfcSpatialStructureElement* v12_MoveTo, boost::optional< std::vector< std::string > /*[1:?]*/ > v13_PunchList); @@ -29184,13 +25914,7 @@ public: /// IFC2x4 CHANGE Attribute made optional. IfcOccupantTypeEnum::IfcOccupantTypeEnum PredefinedType() const; void setPredefinedType(IfcOccupantTypeEnum::IfcOccupantTypeEnum v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_ENUMERATION; } return IfcActor::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcOccupantTypeEnum; } return IfcActor::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "PredefinedType"; } return IfcActor::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOccupant (IfcAbstractEntity* e); IfcOccupant (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcActorSelect* v6_TheActor, IfcOccupantTypeEnum::IfcOccupantTypeEnum v7_PredefinedType); @@ -29400,14 +26124,8 @@ public: /// Figure 36 — Opening with multiple extrusions class IfcOpeningElement : public IfcFeatureElementSubtraction { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcFeatureElementSubtraction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcFeatureElementSubtraction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcFeatureElementSubtraction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelFillsElement >::ptr HasFillings() const; // INVERSE IfcRelFillsElement::RelatingOpeningElement - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelFillsElement >::ptr HasFillings() const; // INVERSE IfcRelFillsElement::RelatingOpeningElement + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOpeningElement (IfcAbstractEntity* e); IfcOpeningElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -29418,13 +26136,7 @@ class IfcOrderAction : public IfcTask { public: std::string ActionID() const; void setActionID(std::string v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_STRING; } return IfcTask::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcIdentifier; } return IfcTask::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "ActionID"; } return IfcTask::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOrderAction (IfcAbstractEntity* e); IfcOrderAction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority, std::string v11_ActionID); @@ -29464,13 +26176,7 @@ public: /// Identifies the predefined types of outlet from which the type required may be set. IfcOutletTypeEnum::IfcOutletTypeEnum PredefinedType() const; void setPredefinedType(IfcOutletTypeEnum::IfcOutletTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcOutletTypeEnum; } return IfcFlowTerminalType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTerminalType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOutletType (IfcAbstractEntity* e); IfcOutletType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcOutletTypeEnum::IfcOutletTypeEnum v10_PredefinedType); @@ -29486,13 +26192,7 @@ public: /// Describes the applicable building life-cycle phase. Typical values should be DESIGNDEVELOPMENT, SCHEMATICDEVELOPMENT, CONSTRUCTIONDOCUMENT, CONSTRUCTION, ASBUILT, COMMISSIONING, OPERATION, etc. std::string LifeCyclePhase() const; void setLifeCyclePhase(std::string v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcLabel; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "LifeCyclePhase"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPerformanceHistory (IfcAbstractEntity* e); IfcPerformanceHistory (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_LifeCyclePhase); @@ -29539,13 +26239,7 @@ class IfcPermit : public IfcControl { public: std::string PermitID() const; void setPermitID(std::string v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "PermitID"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPermit (IfcAbstractEntity* e); IfcPermit (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_PermitID); @@ -29585,13 +26279,7 @@ public: /// The type of pipe fitting. IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum PredefinedType() const; void setPredefinedType(IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowFittingType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcPipeFittingTypeEnum; } return IfcFlowFittingType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowFittingType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPipeFittingType (IfcAbstractEntity* e); IfcPipeFittingType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum v10_PredefinedType); @@ -29635,13 +26323,7 @@ public: /// The type of pipe segment. IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum PredefinedType() const; void setPredefinedType(IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowSegmentType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcPipeSegmentTypeEnum; } return IfcFlowSegmentType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowSegmentType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPipeSegmentType (IfcAbstractEntity* e); IfcPipeSegmentType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum v10_PredefinedType); @@ -29729,13 +26411,7 @@ public: /// Identifies the predefined types of a planar member element from which the type required may be set. IfcPlateTypeEnum::IfcPlateTypeEnum PredefinedType() const; void setPredefinedType(IfcPlateTypeEnum::IfcPlateTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcPlateTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPlateType (IfcAbstractEntity* e); IfcPlateType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPlateTypeEnum::IfcPlateTypeEnum v10_PredefinedType); @@ -29760,13 +26436,7 @@ public: /// The points defining the polyline. IfcTemplatedEntityList< IfcCartesianPoint >::ptr Points() const; void setPoints(IfcTemplatedEntityList< IfcCartesianPoint >::ptr v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcBoundedCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCartesianPoint; } return IfcBoundedCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Points"; } return IfcBoundedCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPolyline (IfcAbstractEntity* e); IfcPolyline (IfcTemplatedEntityList< IfcCartesianPoint >::ptr v1_Points); @@ -29827,16 +26497,10 @@ public: /// its subtypes. class IfcPort : public IfcProduct { public: - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcProduct::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelConnectsPortToElement >::ptr ContainedIn() const; // INVERSE IfcRelConnectsPortToElement::RelatingPort + IfcTemplatedEntityList< IfcRelConnectsPortToElement >::ptr ContainedIn() const; // INVERSE IfcRelConnectsPortToElement::RelatingPort IfcTemplatedEntityList< IfcRelConnectsPorts >::ptr ConnectedFrom() const; // INVERSE IfcRelConnectsPorts::RelatedPort IfcTemplatedEntityList< IfcRelConnectsPorts >::ptr ConnectedTo() const; // INVERSE IfcRelConnectsPorts::RelatingPort - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPort (IfcAbstractEntity* e); IfcPort (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation); @@ -29956,13 +26620,7 @@ public: bool hasUserDefinedProcedureType() const; std::string UserDefinedProcedureType() const; void setUserDefinedProcedureType(std::string v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_ENUMERATION; case 7: return IfcUtil::Argument_STRING; } return IfcProcess::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; case 6: return Type::IfcProcedureTypeEnum; case 7: return Type::IfcLabel; } return IfcProcess::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "ProcedureID"; case 6: return "ProcedureType"; case 7: return "UserDefinedProcedureType"; } return IfcProcess::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProcedure (IfcAbstractEntity* e); IfcProcedure (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_ProcedureID, IfcProcedureTypeEnum::IfcProcedureTypeEnum v7_ProcedureType, boost::optional< std::string > v8_UserDefinedProcedureType); @@ -30033,13 +26691,7 @@ public: /// DONE std::string Status() const; void setStatus(std::string v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_ENUMERATION; case 7: return IfcUtil::Argument_STRING; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; case 6: return Type::IfcProjectOrderTypeEnum; case 7: return Type::IfcLabel; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "ID"; case 6: return "PredefinedType"; case 7: return "Status"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProjectOrder (IfcAbstractEntity* e); IfcProjectOrder (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_ID, IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum v7_PredefinedType, boost::optional< std::string > v8_Status); @@ -30052,13 +26704,7 @@ public: void setRecords(IfcTemplatedEntityList< IfcRelAssignsToProjectOrder >::ptr v); IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum PredefinedType() const; void setPredefinedType(IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENUMERATION; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcRelAssignsToProjectOrder; case 6: return Type::IfcProjectOrderRecordTypeEnum; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "Records"; case 6: return "PredefinedType"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProjectOrderRecord (IfcAbstractEntity* e); IfcProjectOrderRecord (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcTemplatedEntityList< IfcRelAssignsToProjectOrder >::ptr v6_Records, IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum v7_PredefinedType); @@ -30173,13 +26819,7 @@ public: /// RepresentationType : 'Brep' class IfcProjectionElement : public IfcFeatureElementAddition { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcFeatureElementAddition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcFeatureElementAddition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcFeatureElementAddition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProjectionElement (IfcAbstractEntity* e); IfcProjectionElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -30225,13 +26865,7 @@ public: /// Identifies the predefined types of protective device from which the type required may be set. IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowControllerType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcProtectiveDeviceTypeEnum; } return IfcFlowControllerType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowControllerType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProtectiveDeviceType (IfcAbstractEntity* e); IfcProtectiveDeviceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum v10_PredefinedType); @@ -30270,13 +26904,7 @@ public: /// Defines the type of pump typically used in building services. IfcPumpTypeEnum::IfcPumpTypeEnum PredefinedType() const; void setPredefinedType(IfcPumpTypeEnum::IfcPumpTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowMovingDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcPumpTypeEnum; } return IfcFlowMovingDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowMovingDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPumpType (IfcAbstractEntity* e); IfcPumpType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPumpTypeEnum::IfcPumpTypeEnum v10_PredefinedType); @@ -30285,13 +26913,7 @@ public: class IfcRadiusDimension : public IfcDimensionCurveDirectedCallout { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRadiusDimension (IfcAbstractEntity* e); IfcRadiusDimension (IfcEntityList::ptr v1_Contents); @@ -30322,13 +26944,7 @@ public: /// Identifies the predefined types of a railing element from which the type required may be set. IfcRailingTypeEnum::IfcRailingTypeEnum PredefinedType() const; void setPredefinedType(IfcRailingTypeEnum::IfcRailingTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcRailingTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRailingType (IfcAbstractEntity* e); IfcRailingType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRailingTypeEnum::IfcRailingTypeEnum v10_PredefinedType); @@ -30359,13 +26975,7 @@ public: /// Identifies the predefined types of a ramp flight element from which the type required may be set. IfcRampFlightTypeEnum::IfcRampFlightTypeEnum PredefinedType() const; void setPredefinedType(IfcRampFlightTypeEnum::IfcRampFlightTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcRampFlightTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRampFlightType (IfcAbstractEntity* e); IfcRampFlightType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRampFlightTypeEnum::IfcRampFlightTypeEnum v10_PredefinedType); @@ -30395,13 +27005,7 @@ public: /// IFC2x4 CHANGE The attributes RelatingObject and RelatedObjects are demoted from the supertype IfcRelDecomposes. class IfcRelAggregates : public IfcRelDecomposes { public: - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcRelDecomposes::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcRelDecomposes::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcRelDecomposes::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAggregates (IfcAbstractEntity* e); IfcRelAggregates (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcObjectDefinition* v5_RelatingObject, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v6_RelatedObjects); @@ -30414,13 +27018,7 @@ public: bool hasTimeForTask() const; IfcScheduleTimeControl* TimeForTask() const; void setTimeForTask(IfcScheduleTimeControl* v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelAssignsToControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcScheduleTimeControl; } return IfcRelAssignsToControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "TimeForTask"; } return IfcRelAssignsToControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssignsTasks (IfcAbstractEntity* e); IfcRelAssignsTasks (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< IfcObjectTypeEnum::IfcObjectTypeEnum > v6_RelatedObjectsType, IfcControl* v7_RelatingControl, IfcScheduleTimeControl* v8_TimeForTask); @@ -30468,13 +27066,7 @@ public: /// Identifies the predefined types of sanitary terminal from which the type required may be set. IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum PredefinedType() const; void setPredefinedType(IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcSanitaryTerminalTypeEnum; } return IfcFlowTerminalType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTerminalType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSanitaryTerminalType (IfcAbstractEntity* e); IfcSanitaryTerminalType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum v10_PredefinedType); @@ -30555,14 +27147,8 @@ public: bool hasCompletion() const; double Completion() const; void setCompletion(double v); - virtual unsigned int getArgumentCount() const { return 23; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_ENTITY_INSTANCE; case 11: return IfcUtil::Argument_ENTITY_INSTANCE; case 12: return IfcUtil::Argument_ENTITY_INSTANCE; case 13: return IfcUtil::Argument_DOUBLE; case 14: return IfcUtil::Argument_DOUBLE; case 15: return IfcUtil::Argument_DOUBLE; case 16: return IfcUtil::Argument_DOUBLE; case 17: return IfcUtil::Argument_DOUBLE; case 18: return IfcUtil::Argument_BOOL; case 19: return IfcUtil::Argument_ENTITY_INSTANCE; case 20: return IfcUtil::Argument_DOUBLE; case 21: return IfcUtil::Argument_DOUBLE; case 22: return IfcUtil::Argument_DOUBLE; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcDateTimeSelect; case 6: return Type::IfcDateTimeSelect; case 7: return Type::IfcDateTimeSelect; case 8: return Type::IfcDateTimeSelect; case 9: return Type::IfcDateTimeSelect; case 10: return Type::IfcDateTimeSelect; case 11: return Type::IfcDateTimeSelect; case 12: return Type::IfcDateTimeSelect; case 13: return Type::IfcTimeMeasure; case 14: return Type::IfcTimeMeasure; case 15: return Type::IfcTimeMeasure; case 16: return Type::IfcTimeMeasure; case 17: return Type::IfcTimeMeasure; case 18: return Type::UNDEFINED; case 19: return Type::IfcDateTimeSelect; case 20: return Type::IfcTimeMeasure; case 21: return Type::IfcTimeMeasure; case 22: return Type::IfcPositiveRatioMeasure; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "ActualStart"; case 6: return "EarlyStart"; case 7: return "LateStart"; case 8: return "ScheduleStart"; case 9: return "ActualFinish"; case 10: return "EarlyFinish"; case 11: return "LateFinish"; case 12: return "ScheduleFinish"; case 13: return "ScheduleDuration"; case 14: return "ActualDuration"; case 15: return "RemainingTime"; case 16: return "FreeFloat"; case 17: return "TotalFloat"; case 18: return "IsCritical"; case 19: return "StatusTime"; case 20: return "StartFloat"; case 21: return "FinishFloat"; case 22: return "Completion"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssignsTasks >::ptr ScheduleTimeControlAssigned() const; // INVERSE IfcRelAssignsTasks::TimeForTask - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelAssignsTasks >::ptr ScheduleTimeControlAssigned() const; // INVERSE IfcRelAssignsTasks::TimeForTask + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcScheduleTimeControl (IfcAbstractEntity* e); IfcScheduleTimeControl (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcDateTimeSelect* v6_ActualStart, IfcDateTimeSelect* v7_EarlyStart, IfcDateTimeSelect* v8_LateStart, IfcDateTimeSelect* v9_ScheduleStart, IfcDateTimeSelect* v10_ActualFinish, IfcDateTimeSelect* v11_EarlyFinish, IfcDateTimeSelect* v12_LateFinish, IfcDateTimeSelect* v13_ScheduleFinish, boost::optional< double > v14_ScheduleDuration, boost::optional< double > v15_ActualDuration, boost::optional< double > v16_RemainingTime, boost::optional< double > v17_FreeFloat, boost::optional< double > v18_TotalFloat, boost::optional< bool > v19_IsCritical, IfcDateTimeSelect* v20_StatusTime, boost::optional< double > v21_StartFloat, boost::optional< double > v22_FinishFloat, boost::optional< double > v23_Completion); @@ -30575,13 +27161,7 @@ public: void setServiceLifeType(IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum v); double ServiceLifeDuration() const; void setServiceLifeDuration(double v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_DOUBLE; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcServiceLifeTypeEnum; case 6: return Type::IfcTimeMeasure; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "ServiceLifeType"; case 6: return "ServiceLifeDuration"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcServiceLife (IfcAbstractEntity* e); IfcServiceLife (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum v6_ServiceLifeType, double v7_ServiceLifeDuration); @@ -30806,13 +27386,7 @@ public: /// Address given to the site for postal purposes. IfcPostalAddress* SiteAddress() const; void setSiteAddress(IfcPostalAddress* v); - virtual unsigned int getArgumentCount() const { return 14; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_AGGREGATE_OF_INT; case 10: return IfcUtil::Argument_AGGREGATE_OF_INT; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_STRING; case 13: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcSpatialStructureElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcCompoundPlaneAngleMeasure; case 10: return Type::IfcCompoundPlaneAngleMeasure; case 11: return Type::IfcLengthMeasure; case 12: return Type::IfcLabel; case 13: return Type::IfcPostalAddress; } return IfcSpatialStructureElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "RefLatitude"; case 10: return "RefLongitude"; case 11: return "RefElevation"; case 12: return "LandTitleNumber"; case 13: return "SiteAddress"; } return IfcSpatialStructureElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSite (IfcAbstractEntity* e); IfcSite (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, boost::optional< std::vector< int > /*[3:4]*/ > v10_RefLatitude, boost::optional< std::vector< int > /*[3:4]*/ > v11_RefLongitude, boost::optional< double > v12_RefElevation, boost::optional< std::string > v13_LandTitleNumber, IfcPostalAddress* v14_SiteAddress); @@ -30900,13 +27474,7 @@ public: /// Identifies the predefined types of a slab element from which the type required may be set. IfcSlabTypeEnum::IfcSlabTypeEnum PredefinedType() const; void setPredefinedType(IfcSlabTypeEnum::IfcSlabTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcSlabTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSlabType (IfcAbstractEntity* e); IfcSlabType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSlabTypeEnum::IfcSlabTypeEnum v10_PredefinedType); @@ -31171,15 +27739,9 @@ public: /// Level of flooring of this space; the average shall be taken, if the space ground surface is sloping or if there are level differences within this space. double ElevationWithFlooring() const; void setElevationWithFlooring(double v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; case 10: return IfcUtil::Argument_DOUBLE; } return IfcSpatialStructureElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcInternalOrExternalEnum; case 10: return Type::IfcLengthMeasure; } return IfcSpatialStructureElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "InteriorOrExteriorSpace"; case 10: return "ElevationWithFlooring"; } return IfcSpatialStructureElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelCoversSpaces >::ptr HasCoverings() const; // INVERSE IfcRelCoversSpaces::RelatedSpace + IfcTemplatedEntityList< IfcRelCoversSpaces >::ptr HasCoverings() const; // INVERSE IfcRelCoversSpaces::RelatedSpace IfcTemplatedEntityList< IfcRelSpaceBoundary >::ptr BoundedBy() const; // INVERSE IfcRelSpaceBoundary::RelatingSpace - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSpace (IfcAbstractEntity* e); IfcSpace (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, IfcElementCompositionEnum::IfcElementCompositionEnum v9_CompositionType, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v10_InteriorOrExteriorSpace, boost::optional< double > v11_ElevationWithFlooring); @@ -31220,13 +27782,7 @@ public: /// Enumeration of possible types of space heater (e.g., baseboard heater, convector, radiator, etc.). IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum PredefinedType() const; void setPredefinedType(IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcSpaceHeaterTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSpaceHeaterType (IfcAbstractEntity* e); IfcSpaceHeaterType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum v10_PredefinedType); @@ -31251,15 +27807,9 @@ public: void setRequestedLocation(IfcSpatialStructureElement* v); double StandardRequiredArea() const; void setStandardRequiredArea(double v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_DOUBLE; case 7: return IfcUtil::Argument_DOUBLE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_DOUBLE; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; case 6: return Type::IfcAreaMeasure; case 7: return Type::IfcAreaMeasure; case 8: return Type::IfcSpatialStructureElement; case 9: return Type::IfcAreaMeasure; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "SpaceProgramIdentifier"; case 6: return "MaxRequiredArea"; case 7: return "MinRequiredArea"; case 8: return "RequestedLocation"; case 9: return "StandardRequiredArea"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelInteractionRequirements >::ptr HasInteractionReqsFrom() const; // INVERSE IfcRelInteractionRequirements::RelatedSpaceProgram + IfcTemplatedEntityList< IfcRelInteractionRequirements >::ptr HasInteractionReqsFrom() const; // INVERSE IfcRelInteractionRequirements::RelatedSpaceProgram IfcTemplatedEntityList< IfcRelInteractionRequirements >::ptr HasInteractionReqsTo() const; // INVERSE IfcRelInteractionRequirements::RelatingSpaceProgram - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSpaceProgram (IfcAbstractEntity* e); IfcSpaceProgram (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_SpaceProgramIdentifier, boost::optional< double > v7_MaxRequiredArea, boost::optional< double > v8_MinRequiredArea, IfcSpatialStructureElement* v9_RequestedLocation, double v10_StandardRequiredArea); @@ -31351,13 +27901,7 @@ public: /// Predefined types to define the particular type of space. There may be property set definitions available for each predefined type. IfcSpaceTypeEnum::IfcSpaceTypeEnum PredefinedType() const; void setPredefinedType(IfcSpaceTypeEnum::IfcSpaceTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcSpatialStructureElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcSpaceTypeEnum; } return IfcSpatialStructureElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcSpatialStructureElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSpaceType (IfcAbstractEntity* e); IfcSpaceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSpaceTypeEnum::IfcSpaceTypeEnum v10_PredefinedType); @@ -31394,13 +27938,7 @@ public: /// Identifies the predefined types of stack terminal from which the type required may be set. IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum PredefinedType() const; void setPredefinedType(IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcStackTerminalTypeEnum; } return IfcFlowTerminalType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTerminalType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStackTerminalType (IfcAbstractEntity* e); IfcStackTerminalType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum v10_PredefinedType); @@ -31431,13 +27969,7 @@ public: /// Identifies the predefined types of a stair flight element from which the type required may be set. IfcStairFlightTypeEnum::IfcStairFlightTypeEnum PredefinedType() const; void setPredefinedType(IfcStairFlightTypeEnum::IfcStairFlightTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcStairFlightTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStairFlightType (IfcAbstractEntity* e); IfcStairFlightType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcStairFlightTypeEnum::IfcStairFlightTypeEnum v10_PredefinedType); @@ -31471,13 +28003,7 @@ public: bool hasCausedBy() const; IfcStructuralReaction* CausedBy() const; void setCausedBy(IfcStructuralReaction* v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_BOOL; case 10: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcStructuralActivity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::UNDEFINED; case 10: return Type::IfcStructuralReaction; } return IfcStructuralActivity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "DestabilizingLoad"; case 10: return "CausedBy"; } return IfcStructuralActivity::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralAction (IfcAbstractEntity* e); IfcStructuralAction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy); @@ -31493,14 +28019,8 @@ public: /// Optional boundary conditions which define support conditions of this connection object, given in local coordinate directions of the connection object. If left unspecified, the connection object is assumed to have no supports besides being connected with members. IfcBoundaryCondition* AppliedCondition() const; void setAppliedCondition(IfcBoundaryCondition* v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcStructuralItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcBoundaryCondition; } return IfcStructuralItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "AppliedCondition"; } return IfcStructuralItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelConnectsStructuralMember >::ptr ConnectsStructuralMembers() const; // INVERSE IfcRelConnectsStructuralMember::RelatedStructuralConnection - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelConnectsStructuralMember >::ptr ConnectsStructuralMembers() const; // INVERSE IfcRelConnectsStructuralMember::RelatedStructuralConnection + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralConnection (IfcAbstractEntity* e); IfcStructuralConnection (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition); @@ -31525,13 +28045,7 @@ public: /// The reference curve must not be parallel with Axis at any point within the curve connections's domain. class IfcStructuralCurveConnection : public IfcStructuralConnection { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralConnection::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralConnection::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralConnection::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralCurveConnection (IfcAbstractEntity* e); IfcStructuralCurveConnection (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition); @@ -31579,13 +28093,7 @@ public: /// Type of member with respect to its load carrying behavior in this analysis idealization. IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum PredefinedType() const; void setPredefinedType(IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_ENUMERATION; } return IfcStructuralMember::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcStructuralCurveTypeEnum; } return IfcStructuralMember::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "PredefinedType"; } return IfcStructuralMember::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralCurveMember (IfcAbstractEntity* e); IfcStructuralCurveMember (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum v8_PredefinedType); @@ -31613,13 +28121,7 @@ public: /// Instances of IfcStructuralCurveMemberVarying may have a topology representation which contains a single IfcEdgeLoop, based upon the edges of the parts. class IfcStructuralCurveMemberVarying : public IfcStructuralCurveMember { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralCurveMember::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralCurveMember::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralCurveMember::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralCurveMemberVarying (IfcAbstractEntity* e); IfcStructuralCurveMemberVarying (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum v8_PredefinedType); @@ -31636,13 +28138,7 @@ class IfcStructuralLinearAction : public IfcStructuralAction { public: IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum ProjectedOrTrue() const; void setProjectedOrTrue(IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 11: return IfcUtil::Argument_ENUMERATION; } return IfcStructuralAction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 11: return Type::IfcProjectedOrTrueLengthEnum; } return IfcStructuralAction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 11: return "ProjectedOrTrue"; } return IfcStructuralAction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLinearAction (IfcAbstractEntity* e); IfcStructuralLinearAction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue); @@ -31655,13 +28151,7 @@ public: void setVaryingAppliedLoadLocation(IfcShapeAspect* v); IfcTemplatedEntityList< IfcStructuralLoad >::ptr SubsequentAppliedLoads() const; void setSubsequentAppliedLoads(IfcTemplatedEntityList< IfcStructuralLoad >::ptr v); - virtual unsigned int getArgumentCount() const { return 14; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 12: return IfcUtil::Argument_ENTITY_INSTANCE; case 13: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcStructuralLinearAction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 12: return Type::IfcShapeAspect; case 13: return Type::IfcStructuralLoad; } return IfcStructuralLinearAction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 12: return "VaryingAppliedLoadLocation"; case 13: return "SubsequentAppliedLoads"; } return IfcStructuralLinearAction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLinearActionVarying (IfcAbstractEntity* e); IfcStructuralLinearActionVarying (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue, IfcShapeAspect* v13_VaryingAppliedLoadLocation, IfcTemplatedEntityList< IfcStructuralLoad >::ptr v14_SubsequentAppliedLoads); @@ -31721,15 +28211,9 @@ public: /// Description of the purpose of this instance. Among else, possible values of the Purpose of load combinations are 'SLS', 'ULS', 'ALS' to indicate serviceability, ultimate, or accidental limit state. std::string Purpose() const; void setPurpose(std::string v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_ENUMERATION; case 7: return IfcUtil::Argument_ENUMERATION; case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_STRING; } return IfcGroup::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcLoadGroupTypeEnum; case 6: return Type::IfcActionTypeEnum; case 7: return Type::IfcActionSourceTypeEnum; case 8: return Type::IfcRatioMeasure; case 9: return Type::IfcLabel; } return IfcGroup::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "PredefinedType"; case 6: return "ActionType"; case 7: return "ActionSource"; case 8: return "Coefficient"; case 9: return "Purpose"; } return IfcGroup::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcStructuralResultGroup >::ptr SourceOfResultGroup() const; // INVERSE IfcStructuralResultGroup::ResultForLoadGroup + IfcTemplatedEntityList< IfcStructuralResultGroup >::ptr SourceOfResultGroup() const; // INVERSE IfcStructuralResultGroup::ResultForLoadGroup IfcTemplatedEntityList< IfcStructuralAnalysisModel >::ptr LoadGroupFor() const; // INVERSE IfcStructuralAnalysisModel::LoadedBy - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLoadGroup (IfcAbstractEntity* e); IfcStructuralLoadGroup (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum v6_PredefinedType, IfcActionTypeEnum::IfcActionTypeEnum v7_ActionType, IfcActionSourceTypeEnum::IfcActionSourceTypeEnum v8_ActionSource, boost::optional< double > v9_Coefficient, boost::optional< std::string > v10_Purpose); @@ -31746,13 +28230,7 @@ class IfcStructuralPlanarAction : public IfcStructuralAction { public: IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum ProjectedOrTrue() const; void setProjectedOrTrue(IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 11: return IfcUtil::Argument_ENUMERATION; } return IfcStructuralAction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 11: return Type::IfcProjectedOrTrueLengthEnum; } return IfcStructuralAction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 11: return "ProjectedOrTrue"; } return IfcStructuralAction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralPlanarAction (IfcAbstractEntity* e); IfcStructuralPlanarAction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue); @@ -31765,13 +28243,7 @@ public: void setVaryingAppliedLoadLocation(IfcShapeAspect* v); IfcTemplatedEntityList< IfcStructuralLoad >::ptr SubsequentAppliedLoads() const; void setSubsequentAppliedLoads(IfcTemplatedEntityList< IfcStructuralLoad >::ptr v); - virtual unsigned int getArgumentCount() const { return 14; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 12: return IfcUtil::Argument_ENTITY_INSTANCE; case 13: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcStructuralPlanarAction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 12: return Type::IfcShapeAspect; case 13: return Type::IfcStructuralLoad; } return IfcStructuralPlanarAction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 12: return "VaryingAppliedLoadLocation"; case 13: return "SubsequentAppliedLoads"; } return IfcStructuralPlanarAction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralPlanarActionVarying (IfcAbstractEntity* e); IfcStructuralPlanarActionVarying (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy, IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v12_ProjectedOrTrue, IfcShapeAspect* v13_VaryingAppliedLoadLocation, IfcTemplatedEntityList< IfcStructuralLoad >::ptr v14_SubsequentAppliedLoads); @@ -31824,13 +28296,7 @@ public: /// IfcStructuralLoadSingleDisplacement. class IfcStructuralPointAction : public IfcStructuralAction { public: - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralAction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralAction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralAction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralPointAction (IfcAbstractEntity* e); IfcStructuralPointAction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal, bool v10_DestabilizingLoad, IfcStructuralReaction* v11_CausedBy); @@ -31851,13 +28317,7 @@ public: /// Instances of IfcStructuralPointConnection shall have a topology representation which consists of one IfcVertexPoint, representing the reference point of the point connection. See definitions at IfcStructuralItem for further specifications. class IfcStructuralPointConnection : public IfcStructuralConnection { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralConnection::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralConnection::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralConnection::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralPointConnection (IfcAbstractEntity* e); IfcStructuralPointConnection (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition); @@ -31908,13 +28368,7 @@ public: /// IfcStructuralLoadSingleDisplacement. class IfcStructuralPointReaction : public IfcStructuralReaction { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralReaction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralReaction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralReaction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralPointReaction (IfcAbstractEntity* e); IfcStructuralPointReaction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcStructuralLoad* v8_AppliedLoad, IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum v9_GlobalOrLocal); @@ -31937,14 +28391,8 @@ public: /// This value allows to easily recognize whether a linear analysis has been applied (allowing the superposition of analysis results). bool IsLinear() const; void setIsLinear(bool v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_BOOL; } return IfcGroup::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcAnalysisTheoryTypeEnum; case 6: return Type::IfcStructuralLoadGroup; case 7: return Type::UNDEFINED; } return IfcGroup::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "TheoryType"; case 6: return "ResultForLoadGroup"; case 7: return "IsLinear"; } return IfcGroup::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcStructuralAnalysisModel >::ptr ResultGroupFor() const; // INVERSE IfcStructuralAnalysisModel::HasResults - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcStructuralAnalysisModel >::ptr ResultGroupFor() const; // INVERSE IfcStructuralAnalysisModel::HasResults + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralResultGroup (IfcAbstractEntity* e); IfcStructuralResultGroup (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum v6_TheoryType, IfcStructuralLoadGroup* v7_ResultForLoadGroup, bool v8_IsLinear); @@ -31964,13 +28412,7 @@ public: /// Instances of IfcStructuralSurfaceConnection shall have a topology representation which consists of one IfcFaceSurface, representing the reference surface of the surface connection. See definitions at IfcStructuralItem for further specifications. class IfcStructuralSurfaceConnection : public IfcStructuralConnection { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralConnection::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralConnection::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralConnection::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralSurfaceConnection (IfcAbstractEntity* e); IfcStructuralSurfaceConnection (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, IfcBoundaryCondition* v8_AppliedCondition); @@ -32010,13 +28452,7 @@ public: bool hasJobDescription() const; std::string JobDescription() const; void setJobDescription(std::string v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_STRING; } return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcActorSelect; case 10: return Type::IfcText; } return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "SubContractor"; case 10: return "JobDescription"; } return IfcConstructionResource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSubContractResource (IfcAbstractEntity* e); IfcSubContractResource (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity, IfcActorSelect* v10_SubContractor, boost::optional< std::string > v11_JobDescription); @@ -32067,13 +28503,7 @@ public: /// Identifies the predefined types of switch from which the type required may be set. IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowControllerType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcSwitchingDeviceTypeEnum; } return IfcFlowControllerType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowControllerType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSwitchingDeviceType (IfcAbstractEntity* e); IfcSwitchingDeviceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum v10_PredefinedType); @@ -32098,14 +28528,8 @@ public: /// IFC Release 1.0 class IfcSystem : public IfcGroup { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcGroup::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcGroup::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcGroup::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelServicesBuildings >::ptr ServicesBuildings() const; // INVERSE IfcRelServicesBuildings::RelatingSystem - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelServicesBuildings >::ptr ServicesBuildings() const; // INVERSE IfcRelServicesBuildings::RelatingSystem + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSystem (IfcAbstractEntity* e); IfcSystem (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -32148,13 +28572,7 @@ public: /// Defines the type of tank. IfcTankTypeEnum::IfcTankTypeEnum PredefinedType() const; void setPredefinedType(IfcTankTypeEnum::IfcTankTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowStorageDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcTankTypeEnum; } return IfcFlowStorageDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowStorageDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTankType (IfcAbstractEntity* e); IfcTankType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTankTypeEnum::IfcTankTypeEnum v10_PredefinedType); @@ -32171,13 +28589,7 @@ public: void setTimeSeriesScheduleType(IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum v); IfcTimeSeries* TimeSeries() const; void setTimeSeries(IfcTimeSeries* v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENUMERATION; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcDateTimeSelect; case 6: return Type::IfcTimeSeriesScheduleTypeEnum; case 7: return Type::IfcTimeSeries; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "ApplicableDates"; case 6: return "TimeSeriesScheduleType"; case 7: return "TimeSeries"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTimeSeriesSchedule (IfcAbstractEntity* e); IfcTimeSeriesSchedule (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< IfcEntityList::ptr > v6_ApplicableDates, IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum v7_TimeSeriesScheduleType, IfcTimeSeries* v8_TimeSeries); @@ -32215,13 +28627,7 @@ public: /// Identifies the predefined types of transformer from which the type required may be set. IfcTransformerTypeEnum::IfcTransformerTypeEnum PredefinedType() const; void setPredefinedType(IfcTransformerTypeEnum::IfcTransformerTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcTransformerTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTransformerType (IfcAbstractEntity* e); IfcTransformerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTransformerTypeEnum::IfcTransformerTypeEnum v10_PredefinedType); @@ -32359,13 +28765,7 @@ public: /// Capacity of the transportation element measured in numbers of person. double CapacityByNumber() const; void setCapacityByNumber(double v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; } return IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcTransportElementTypeEnum; case 9: return Type::IfcMassMeasure; case 10: return Type::IfcCountMeasure; } return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "OperationType"; case 9: return "CapacityByWeight"; case 10: return "CapacityByNumber"; } return IfcElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTransportElement (IfcAbstractEntity* e); IfcTransportElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcTransportElementTypeEnum::IfcTransportElementTypeEnum > v9_OperationType, boost::optional< double > v10_CapacityByWeight, boost::optional< double > v11_CapacityByNumber); @@ -32466,13 +28866,7 @@ public: /// Where both parameter and point are present at either end of the curve this indicates the preferred form. IfcTrimmingPreference::IfcTrimmingPreference MasterRepresentation() const; void setMasterRepresentation(IfcTrimmingPreference::IfcTrimmingPreference v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_BOOL; case 4: return IfcUtil::Argument_ENUMERATION; } return IfcBoundedCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCurve; case 1: return Type::IfcTrimmingSelect; case 2: return Type::IfcTrimmingSelect; case 3: return Type::UNDEFINED; case 4: return Type::IfcTrimmingPreference; } return IfcBoundedCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BasisCurve"; case 1: return "Trim1"; case 2: return "Trim2"; case 3: return "SenseAgreement"; case 4: return "MasterRepresentation"; } return IfcBoundedCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTrimmedCurve (IfcAbstractEntity* e); IfcTrimmedCurve (IfcCurve* v1_BasisCurve, IfcEntityList::ptr v2_Trim1, IfcEntityList::ptr v3_Trim2, bool v4_SenseAgreement, IfcTrimmingPreference::IfcTrimmingPreference v5_MasterRepresentation); @@ -32512,13 +28906,7 @@ public: /// Defines the type of tube bundle. IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum PredefinedType() const; void setPredefinedType(IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcTubeBundleTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTubeBundleType (IfcAbstractEntity* e); IfcTubeBundleType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum v10_PredefinedType); @@ -32557,13 +28945,7 @@ public: /// The type of unitary equipment. IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum PredefinedType() const; void setPredefinedType(IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcUnitaryEquipmentTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcUnitaryEquipmentType (IfcAbstractEntity* e); IfcUnitaryEquipmentType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum v10_PredefinedType); @@ -32612,13 +28994,7 @@ public: /// The type of valve. IfcValveTypeEnum::IfcValveTypeEnum PredefinedType() const; void setPredefinedType(IfcValveTypeEnum::IfcValveTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowControllerType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcValveTypeEnum; } return IfcFlowControllerType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowControllerType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcValveType (IfcAbstractEntity* e); IfcValveType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcValveTypeEnum::IfcValveTypeEnum v10_PredefinedType); @@ -32712,13 +29088,7 @@ public: /// shown above. class IfcVirtualElement : public IfcElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcVirtualElement (IfcAbstractEntity* e); IfcVirtualElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -32813,13 +29183,7 @@ public: /// Identifies the predefined types of a wall element from which the type required may be set. IfcWallTypeEnum::IfcWallTypeEnum PredefinedType() const; void setPredefinedType(IfcWallTypeEnum::IfcWallTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcWallTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWallType (IfcAbstractEntity* e); IfcWallType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcWallTypeEnum::IfcWallTypeEnum v10_PredefinedType); @@ -32866,13 +29230,7 @@ public: /// Identifies the predefined types of waste terminal from which the type required may be set. IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum PredefinedType() const; void setPredefinedType(IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcWasteTerminalTypeEnum; } return IfcFlowTerminalType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTerminalType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWasteTerminalType (IfcAbstractEntity* e); IfcWasteTerminalType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum v10_PredefinedType); @@ -32965,13 +29323,7 @@ public: bool hasUserDefinedControlType() const; std::string UserDefinedControlType() const; void setUserDefinedControlType(std::string v); - virtual unsigned int getArgumentCount() const { return 15; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_STRING; case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_ENTITY_INSTANCE; case 12: return IfcUtil::Argument_ENTITY_INSTANCE; case 13: return IfcUtil::Argument_ENUMERATION; case 14: return IfcUtil::Argument_STRING; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; case 6: return Type::IfcDateTimeSelect; case 7: return Type::IfcPerson; case 8: return Type::IfcLabel; case 9: return Type::IfcTimeMeasure; case 10: return Type::IfcTimeMeasure; case 11: return Type::IfcDateTimeSelect; case 12: return Type::IfcDateTimeSelect; case 13: return Type::IfcWorkControlTypeEnum; case 14: return Type::IfcLabel; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "Identifier"; case 6: return "CreationDate"; case 7: return "Creators"; case 8: return "Purpose"; case 9: return "Duration"; case 10: return "TotalFloat"; case 11: return "StartTime"; case 12: return "FinishTime"; case 13: return "WorkControlType"; case 14: return "UserDefinedControlType"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWorkControl (IfcAbstractEntity* e); IfcWorkControl (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, IfcDateTimeSelect* v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, IfcDateTimeSelect* v12_StartTime, IfcDateTimeSelect* v13_FinishTime, boost::optional< IfcWorkControlTypeEnum::IfcWorkControlTypeEnum > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType); @@ -33004,13 +29356,7 @@ public: /// Figure 18 — Work plan relationships class IfcWorkPlan : public IfcWorkControl { public: - virtual unsigned int getArgumentCount() const { return 15; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcWorkControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcWorkControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcWorkControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWorkPlan (IfcAbstractEntity* e); IfcWorkPlan (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, IfcDateTimeSelect* v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, IfcDateTimeSelect* v12_StartTime, IfcDateTimeSelect* v13_FinishTime, boost::optional< IfcWorkControlTypeEnum::IfcWorkControlTypeEnum > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType); @@ -33058,13 +29404,7 @@ public: /// Figure 19 — Work schedule relationships class IfcWorkSchedule : public IfcWorkControl { public: - virtual unsigned int getArgumentCount() const { return 15; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcWorkControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcWorkControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcWorkControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWorkSchedule (IfcAbstractEntity* e); IfcWorkSchedule (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, IfcDateTimeSelect* v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, IfcDateTimeSelect* v12_StartTime, IfcDateTimeSelect* v13_FinishTime, boost::optional< IfcWorkControlTypeEnum::IfcWorkControlTypeEnum > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType); @@ -33157,13 +29497,7 @@ public: /// requirements class IfcZone : public IfcGroup { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcGroup::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcGroup::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcGroup::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcZone (IfcAbstractEntity* e); IfcZone (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -33172,13 +29506,7 @@ public: class Ifc2DCompositeCurve : public IfcCompositeCurve { public: - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcCompositeCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcCompositeCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcCompositeCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); Ifc2DCompositeCurve (IfcAbstractEntity* e); Ifc2DCompositeCurve (IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect); @@ -33226,13 +29554,7 @@ class IfcActionRequest : public IfcControl { public: std::string RequestID() const; void setRequestID(std::string v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RequestID"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcActionRequest (IfcAbstractEntity* e); IfcActionRequest (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_RequestID); @@ -33269,13 +29591,7 @@ public: /// The air terminal box type. IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum PredefinedType() const; void setPredefinedType(IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowControllerType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcAirTerminalBoxTypeEnum; } return IfcFlowControllerType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowControllerType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAirTerminalBoxType (IfcAbstractEntity* e); IfcAirTerminalBoxType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum v10_PredefinedType); @@ -33311,13 +29627,7 @@ class IfcAirTerminalType : public IfcFlowTerminalType { public: IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum PredefinedType() const; void setPredefinedType(IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcAirTerminalTypeEnum; } return IfcFlowTerminalType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTerminalType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAirTerminalType (IfcAbstractEntity* e); IfcAirTerminalType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum v10_PredefinedType); @@ -33354,13 +29664,7 @@ public: /// Defines the type of air to air heat recovery device. IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum PredefinedType() const; void setPredefinedType(IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcAirToAirHeatRecoveryTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAirToAirHeatRecoveryType (IfcAbstractEntity* e); IfcAirToAirHeatRecoveryType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum v10_PredefinedType); @@ -33369,13 +29673,7 @@ public: class IfcAngularDimension : public IfcDimensionCurveDirectedCallout { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAngularDimension (IfcAbstractEntity* e); IfcAngularDimension (IfcEntityList::ptr v1_Contents); @@ -33437,13 +29735,7 @@ public: /// The current value of an asset within the accounting rules and procedures of an organization. IfcCostValue* DepreciatedValue() const; void setDepreciatedValue(IfcCostValue* v); - virtual unsigned int getArgumentCount() const { return 14; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_ENTITY_INSTANCE; case 11: return IfcUtil::Argument_ENTITY_INSTANCE; case 12: return IfcUtil::Argument_ENTITY_INSTANCE; case 13: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcGroup::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; case 6: return Type::IfcCostValue; case 7: return Type::IfcCostValue; case 8: return Type::IfcCostValue; case 9: return Type::IfcActorSelect; case 10: return Type::IfcActorSelect; case 11: return Type::IfcPerson; case 12: return Type::IfcCalendarDate; case 13: return Type::IfcCostValue; } return IfcGroup::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "AssetID"; case 6: return "OriginalValue"; case 7: return "CurrentValue"; case 8: return "TotalReplacementCost"; case 9: return "Owner"; case 10: return "User"; case 11: return "ResponsiblePerson"; case 12: return "IncorporationDate"; case 13: return "DepreciatedValue"; } return IfcGroup::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAsset (IfcAbstractEntity* e); IfcAsset (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_AssetID, IfcCostValue* v7_OriginalValue, IfcCostValue* v8_CurrentValue, IfcCostValue* v9_TotalReplacementCost, IfcActorSelect* v10_Owner, IfcActorSelect* v11_User, IfcPerson* v12_ResponsiblePerson, IfcCalendarDate* v13_IncorporationDate, IfcCostValue* v14_DepreciatedValue); @@ -33515,13 +29807,7 @@ public: /// Indication whether the curve self-intersects or not; it is for information only. bool SelfIntersect() const; void setSelfIntersect(bool v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_INT; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_BOOL; case 4: return IfcUtil::Argument_BOOL; } return IfcBoundedCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::UNDEFINED; case 1: return Type::IfcCartesianPoint; case 2: return Type::IfcBSplineCurveForm; case 3: return Type::UNDEFINED; case 4: return Type::UNDEFINED; } return IfcBoundedCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Degree"; case 1: return "ControlPointsList"; case 2: return "CurveForm"; case 3: return "ClosedCurve"; case 4: return "SelfIntersect"; } return IfcBoundedCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBSplineCurve (IfcAbstractEntity* e); IfcBSplineCurve (int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect); @@ -33630,13 +29916,7 @@ public: /// Identifies the predefined types of a beam element from which the type required may be set. IfcBeamTypeEnum::IfcBeamTypeEnum PredefinedType() const; void setPredefinedType(IfcBeamTypeEnum::IfcBeamTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcBeamTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBeamType (IfcAbstractEntity* e); IfcBeamType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBeamTypeEnum::IfcBeamTypeEnum v10_PredefinedType); @@ -33645,13 +29925,7 @@ public: class IfcBezierCurve : public IfcBSplineCurve { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBSplineCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBSplineCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBSplineCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBezierCurve (IfcAbstractEntity* e); IfcBezierCurve (int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect); @@ -33691,13 +29965,7 @@ public: /// Defines types of boilers. IfcBoilerTypeEnum::IfcBoilerTypeEnum PredefinedType() const; void setPredefinedType(IfcBoilerTypeEnum::IfcBoilerTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcBoilerTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoilerType (IfcAbstractEntity* e); IfcBoilerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBoilerTypeEnum::IfcBoilerTypeEnum v10_PredefinedType); @@ -34068,13 +30336,7 @@ public: /// IfcRepresentationMap. class IfcBuildingElement : public IfcElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBuildingElement (IfcAbstractEntity* e); IfcBuildingElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -34083,13 +30345,7 @@ public: class IfcBuildingElementComponent : public IfcBuildingElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBuildingElementComponent (IfcAbstractEntity* e); IfcBuildingElementComponent (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -34114,13 +30370,7 @@ public: /// attribute PredefinedType added. class IfcBuildingElementPart : public IfcBuildingElementComponent { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBuildingElementComponent::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBuildingElementComponent::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBuildingElementComponent::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBuildingElementPart (IfcAbstractEntity* e); IfcBuildingElementPart (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -34322,13 +30572,7 @@ public: bool hasCompositionType() const; IfcElementCompositionEnum::IfcElementCompositionEnum CompositionType() const; void setCompositionType(IfcElementCompositionEnum::IfcElementCompositionEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcElementCompositionEnum; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "CompositionType"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBuildingElementProxy (IfcAbstractEntity* e); IfcBuildingElementProxy (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcElementCompositionEnum::IfcElementCompositionEnum > v9_CompositionType); @@ -34373,13 +30617,7 @@ public: /// Predefined types to define the particular type of an building element proxy. There may be property set definitions available for each predefined or user defined type. IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum PredefinedType() const; void setPredefinedType(IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcBuildingElementProxyTypeEnum; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcBuildingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBuildingElementProxyType (IfcAbstractEntity* e); IfcBuildingElementProxyType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum v10_PredefinedType); @@ -34416,13 +30654,7 @@ public: /// Identifies the predefined types of cable carrier fitting from which the type required may be set. IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum PredefinedType() const; void setPredefinedType(IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowFittingType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcCableCarrierFittingTypeEnum; } return IfcFlowFittingType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowFittingType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCableCarrierFittingType (IfcAbstractEntity* e); IfcCableCarrierFittingType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum v10_PredefinedType); @@ -34465,13 +30697,7 @@ public: /// Identifies the predefined types of cable carrier segment from which the type required may be set. IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum PredefinedType() const; void setPredefinedType(IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowSegmentType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcCableCarrierSegmentTypeEnum; } return IfcFlowSegmentType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowSegmentType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCableCarrierSegmentType (IfcAbstractEntity* e); IfcCableCarrierSegmentType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum v10_PredefinedType); @@ -34523,13 +30749,7 @@ public: /// Identifies the predefined types of cable segment from which the type required may be set. IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum PredefinedType() const; void setPredefinedType(IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowSegmentType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcCableSegmentTypeEnum; } return IfcFlowSegmentType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowSegmentType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCableSegmentType (IfcAbstractEntity* e); IfcCableSegmentType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum v10_PredefinedType); @@ -34572,13 +30792,7 @@ public: /// Defines the typical types of chillers (e.g., air-cooled, water-cooled, etc.). IfcChillerTypeEnum::IfcChillerTypeEnum PredefinedType() const; void setPredefinedType(IfcChillerTypeEnum::IfcChillerTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcChillerTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcChillerType (IfcAbstractEntity* e); IfcChillerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcChillerTypeEnum::IfcChillerTypeEnum v10_PredefinedType); @@ -34616,13 +30830,7 @@ public: /// The radius of the circle, which shall be greater than zero. double Radius() const; void setRadius(double v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_DOUBLE; } return IfcConic::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcPositiveLengthMeasure; } return IfcConic::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Radius"; } return IfcConic::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCircle (IfcAbstractEntity* e); IfcCircle (IfcAxis2Placement* v1_Position, double v2_Radius); @@ -34660,13 +30868,7 @@ public: /// Defines typical types of coils (e.g., Cooling, Heating, etc.) IfcCoilTypeEnum::IfcCoilTypeEnum PredefinedType() const; void setPredefinedType(IfcCoilTypeEnum::IfcCoilTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcCoilTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCoilType (IfcAbstractEntity* e); IfcCoilType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCoilTypeEnum::IfcCoilTypeEnum v10_PredefinedType); @@ -34945,13 +31147,7 @@ public: /// IfcRepresentationMap. class IfcColumn : public IfcBuildingElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcColumn (IfcAbstractEntity* e); IfcColumn (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -34989,13 +31185,7 @@ public: /// Defines the type of compressor (e.g., hermetic, reciprocating, etc.). IfcCompressorTypeEnum::IfcCompressorTypeEnum PredefinedType() const; void setPredefinedType(IfcCompressorTypeEnum::IfcCompressorTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowMovingDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcCompressorTypeEnum; } return IfcFlowMovingDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowMovingDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCompressorType (IfcAbstractEntity* e); IfcCompressorType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCompressorTypeEnum::IfcCompressorTypeEnum v10_PredefinedType); @@ -35033,13 +31223,7 @@ public: /// Defines the type of condenser. IfcCondenserTypeEnum::IfcCondenserTypeEnum PredefinedType() const; void setPredefinedType(IfcCondenserTypeEnum::IfcCondenserTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcCondenserTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCondenserType (IfcAbstractEntity* e); IfcCondenserType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCondenserTypeEnum::IfcCondenserTypeEnum v10_PredefinedType); @@ -35048,13 +31232,7 @@ public: class IfcCondition : public IfcGroup { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcGroup::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcGroup::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcGroup::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCondition (IfcAbstractEntity* e); IfcCondition (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -35067,13 +31245,7 @@ public: void setCriterion(IfcConditionCriterionSelect* v); IfcDateTimeSelect* CriterionDateTime() const; void setCriterionDateTime(IfcDateTimeSelect* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcConditionCriterionSelect; case 6: return Type::IfcDateTimeSelect; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "Criterion"; case 6: return "CriterionDateTime"; } return IfcControl::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConditionCriterion (IfcAbstractEntity* e); IfcConditionCriterion (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcConditionCriterionSelect* v6_Criterion, IfcDateTimeSelect* v7_CriterionDateTime); @@ -35103,13 +31275,7 @@ public: /// Figure 183 — Construction equipment resource assignment class IfcConstructionEquipmentResource : public IfcConstructionResource { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcConstructionResource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstructionEquipmentResource (IfcAbstractEntity* e); IfcConstructionEquipmentResource (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity); @@ -35151,13 +31317,7 @@ public: bool hasUsageRatio() const; double UsageRatio() const; void setUsageRatio(double v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_DOUBLE; } return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcActorSelect; case 10: return Type::IfcRatioMeasure; } return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "Suppliers"; case 10: return "UsageRatio"; } return IfcConstructionResource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstructionMaterialResource (IfcAbstractEntity* e); IfcConstructionMaterialResource (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity, boost::optional< IfcEntityList::ptr > v10_Suppliers, boost::optional< double > v11_UsageRatio); @@ -35180,13 +31340,7 @@ public: /// Figure 185 — Construction product resource assignment class IfcConstructionProductResource : public IfcConstructionResource { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcConstructionResource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstructionProductResource (IfcAbstractEntity* e); IfcConstructionProductResource (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< IfcResourceConsumptionEnum::IfcResourceConsumptionEnum > v8_ResourceConsumption, IfcMeasureWithUnit* v9_BaseQuantity); @@ -35226,13 +31380,7 @@ public: /// Defines the type of cooled beam. IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum PredefinedType() const; void setPredefinedType(IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcCooledBeamTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCooledBeamType (IfcAbstractEntity* e); IfcCooledBeamType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum v10_PredefinedType); @@ -35276,13 +31424,7 @@ public: /// Defines the typical types of cooling towers (e.g., OpenTower, ClosedTower, CrossFlow, etc.). IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum PredefinedType() const; void setPredefinedType(IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcCoolingTowerTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCoolingTowerType (IfcAbstractEntity* e); IfcCoolingTowerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum v10_PredefinedType); @@ -35519,15 +31661,9 @@ public: /// Predefined types to define the particular type of the covering. There may be property set definitions available for each predefined type. IfcCoveringTypeEnum::IfcCoveringTypeEnum PredefinedType() const; void setPredefinedType(IfcCoveringTypeEnum::IfcCoveringTypeEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcCoveringTypeEnum; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelCoversSpaces >::ptr CoversSpaces() const; // INVERSE IfcRelCoversSpaces::RelatedCoverings + IfcTemplatedEntityList< IfcRelCoversSpaces >::ptr CoversSpaces() const; // INVERSE IfcRelCoversSpaces::RelatedCoverings IfcTemplatedEntityList< IfcRelCoversBldgElements >::ptr Covers() const; // INVERSE IfcRelCoversBldgElements::RelatedCoverings - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCovering (IfcAbstractEntity* e); IfcCovering (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcCoveringTypeEnum::IfcCoveringTypeEnum > v9_PredefinedType); @@ -35673,13 +31809,7 @@ public: /// components of the curtain wall are defined. class IfcCurtainWall : public IfcBuildingElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCurtainWall (IfcAbstractEntity* e); IfcCurtainWall (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -35724,13 +31854,7 @@ public: /// Type of damper. IfcDamperTypeEnum::IfcDamperTypeEnum PredefinedType() const; void setPredefinedType(IfcDamperTypeEnum::IfcDamperTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowControllerType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcDamperTypeEnum; } return IfcFlowControllerType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowControllerType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDamperType (IfcAbstractEntity* e); IfcDamperType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDamperTypeEnum::IfcDamperTypeEnum v10_PredefinedType); @@ -35739,13 +31863,7 @@ public: class IfcDiameterDimension : public IfcDimensionCurveDirectedCallout { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDimensionCurveDirectedCallout::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDiameterDimension (IfcAbstractEntity* e); IfcDiameterDimension (IfcEntityList::ptr v1_Contents); @@ -35926,13 +32044,7 @@ public: /// which multiple brackets can be mounted. class IfcDiscreteAccessory : public IfcElementComponent { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElementComponent::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElementComponent::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElementComponent::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDiscreteAccessory (IfcAbstractEntity* e); IfcDiscreteAccessory (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -36128,13 +32240,7 @@ public: /// which multiple brackets can be mounted. class IfcDiscreteAccessoryType : public IfcElementComponentType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElementComponentType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElementComponentType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElementComponentType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDiscreteAccessoryType (IfcAbstractEntity* e); IfcDiscreteAccessoryType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -36182,13 +32288,7 @@ public: /// Predefined types of distribution chambers. IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum PredefinedType() const; void setPredefinedType(IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcDistributionFlowElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcDistributionChamberElementTypeEnum; } return IfcDistributionFlowElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcDistributionFlowElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDistributionChamberElementType (IfcAbstractEntity* e); IfcDistributionChamberElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum v10_PredefinedType); @@ -36250,13 +32350,7 @@ public: /// NOTE: The product representations are defined as representation maps (at the level of the supertype IfcTypeProduct, which get assigned by an element occurrence instance through the IfcShapeRepresentation.Item[1] being an IfcMappedItem. class IfcDistributionControlElementType : public IfcDistributionElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDistributionControlElementType (IfcAbstractEntity* e); IfcDistributionControlElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -36426,13 +32520,7 @@ public: /// RepresentationType : 'SectionedSpine' class IfcDistributionElement : public IfcElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDistributionElement (IfcAbstractEntity* e); IfcDistributionElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -36508,14 +32596,8 @@ public: /// Representations are further defined at subtypes; for example, parametric flow segments align material profiles with the 'Axis' representation. class IfcDistributionFlowElement : public IfcDistributionElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelFlowControlElements >::ptr HasControlElements() const; // INVERSE IfcRelFlowControlElements::RelatingFlowElement - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelFlowControlElements >::ptr HasControlElements() const; // INVERSE IfcRelFlowControlElements::RelatingFlowElement + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDistributionFlowElement (IfcAbstractEntity* e); IfcDistributionFlowElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -36610,13 +32692,7 @@ public: /// Enumeration that identifies if this port is a Sink (inlet), a Source (outlet) or both a SinkAndSource. IfcFlowDirectionEnum::IfcFlowDirectionEnum FlowDirection() const; void setFlowDirection(IfcFlowDirectionEnum::IfcFlowDirectionEnum v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_ENUMERATION; } return IfcPort::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcFlowDirectionEnum; } return IfcPort::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "FlowDirection"; } return IfcPort::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDistributionPort (IfcAbstractEntity* e); IfcDistributionPort (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< IfcFlowDirectionEnum::IfcFlowDirectionEnum > v8_FlowDirection); @@ -36994,13 +33070,7 @@ public: /// NOTE  The body of the door might be wider then the door opening (e.g. in cases where the door lining includes a casing). In these cases the OverallWidth shall still be given as the door opening width, and not as the total width of the door lining. double OverallWidth() const; void setOverallWidth(double v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcPositiveLengthMeasure; case 9: return Type::IfcPositiveLengthMeasure; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "OverallHeight"; case 9: return "OverallWidth"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDoor (IfcAbstractEntity* e); IfcDoor (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_OverallHeight, boost::optional< double > v10_OverallWidth); @@ -37040,13 +33110,7 @@ public: /// The type of duct fitting. IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum PredefinedType() const; void setPredefinedType(IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowFittingType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcDuctFittingTypeEnum; } return IfcFlowFittingType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowFittingType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDuctFittingType (IfcAbstractEntity* e); IfcDuctFittingType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum v10_PredefinedType); @@ -37086,13 +33150,7 @@ public: /// The type of duct segment. IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum PredefinedType() const; void setPredefinedType(IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowSegmentType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcDuctSegmentTypeEnum; } return IfcFlowSegmentType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowSegmentType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDuctSegmentType (IfcAbstractEntity* e); IfcDuctSegmentType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum v10_PredefinedType); @@ -37129,13 +33187,7 @@ public: /// The type of duct silencer. IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum PredefinedType() const; void setPredefinedType(IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTreatmentDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcDuctSilencerTypeEnum; } return IfcFlowTreatmentDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTreatmentDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDuctSilencerType (IfcAbstractEntity* e); IfcDuctSilencerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum v10_PredefinedType); @@ -37148,13 +33200,7 @@ public: bool hasFeatureLength() const; double FeatureLength() const; void setFeatureLength(double v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_DOUBLE; } return IfcFeatureElementSubtraction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcPositiveLengthMeasure; } return IfcFeatureElementSubtraction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "FeatureLength"; } return IfcFeatureElementSubtraction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEdgeFeature (IfcAbstractEntity* e); IfcEdgeFeature (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength); @@ -37194,13 +33240,7 @@ public: /// Identifies the predefined types of electrical appliance from which the type required may be set. IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcElectricApplianceTypeEnum; } return IfcFlowTerminalType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTerminalType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricApplianceType (IfcAbstractEntity* e); IfcElectricApplianceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum v10_PredefinedType); @@ -37238,13 +33278,7 @@ public: /// Identifies the predefined types of electric flow storage devices from which the type required may be set. IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowStorageDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcElectricFlowStorageDeviceTypeEnum; } return IfcFlowStorageDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowStorageDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricFlowStorageDeviceType (IfcAbstractEntity* e); IfcElectricFlowStorageDeviceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum v10_PredefinedType); @@ -37287,13 +33321,7 @@ public: /// Identifies the predefined types of electric generators from which the type required may be set. IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcElectricGeneratorTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricGeneratorType (IfcAbstractEntity* e); IfcElectricGeneratorType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum v10_PredefinedType); @@ -37304,13 +33332,7 @@ class IfcElectricHeaterType : public IfcFlowTerminalType { public: IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcElectricHeaterTypeEnum; } return IfcFlowTerminalType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTerminalType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricHeaterType (IfcAbstractEntity* e); IfcElectricHeaterType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum v10_PredefinedType); @@ -37348,13 +33370,7 @@ public: /// Identifies the predefined types of electric motor from which the type required may be set. IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcEnergyConversionDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcElectricMotorTypeEnum; } return IfcEnergyConversionDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcEnergyConversionDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricMotorType (IfcAbstractEntity* e); IfcElectricMotorType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum v10_PredefinedType); @@ -37392,13 +33408,7 @@ public: /// Identifies the predefined types of electrical time control from which the type required may be set. IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowControllerType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcElectricTimeControlTypeEnum; } return IfcFlowControllerType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowControllerType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricTimeControlType (IfcAbstractEntity* e); IfcElectricTimeControlType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum v10_PredefinedType); @@ -37407,13 +33417,7 @@ public: class IfcElectricalCircuit : public IfcSystem { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcSystem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcSystem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcSystem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricalCircuit (IfcAbstractEntity* e); IfcElectricalCircuit (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType); @@ -37422,13 +33426,7 @@ public: class IfcElectricalElement : public IfcElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricalElement (IfcAbstractEntity* e); IfcElectricalElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -37445,13 +33443,7 @@ public: /// IFC 2x4 NOTE: This entity has been deprecated for instantiation and will become ABSTRACT in a future release; new subtypes should now be used instead. class IfcEnergyConversionDevice : public IfcDistributionFlowElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEnergyConversionDevice (IfcAbstractEntity* e); IfcEnergyConversionDevice (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -37490,13 +33482,7 @@ public: /// Defines the type of fan typically used in building services. IfcFanTypeEnum::IfcFanTypeEnum PredefinedType() const; void setPredefinedType(IfcFanTypeEnum::IfcFanTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowMovingDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcFanTypeEnum; } return IfcFlowMovingDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowMovingDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFanType (IfcAbstractEntity* e); IfcFanType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFanTypeEnum::IfcFanTypeEnum v10_PredefinedType); @@ -37536,13 +33522,7 @@ public: /// The type of air filter. IfcFilterTypeEnum::IfcFilterTypeEnum PredefinedType() const; void setPredefinedType(IfcFilterTypeEnum::IfcFilterTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTreatmentDeviceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcFilterTypeEnum; } return IfcFlowTreatmentDeviceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTreatmentDeviceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFilterType (IfcAbstractEntity* e); IfcFilterType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFilterTypeEnum::IfcFilterTypeEnum v10_PredefinedType); @@ -37586,13 +33566,7 @@ public: /// Identifies the predefined types of fire suppression terminal from which the type required may be set. IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum PredefinedType() const; void setPredefinedType(IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcFireSuppressionTerminalTypeEnum; } return IfcFlowTerminalType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcFlowTerminalType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFireSuppressionTerminalType (IfcAbstractEntity* e); IfcFireSuppressionTerminalType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum v10_PredefinedType); @@ -37609,13 +33583,7 @@ public: /// IFC 2x4 NOTE: This entity has been deprecated for instantiation and will become ABSTRACT in a future release; new subtypes should now be used instead. class IfcFlowController : public IfcDistributionFlowElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowController (IfcAbstractEntity* e); IfcFlowController (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -37628,13 +33596,7 @@ public: /// IFC 2x4 NOTE: This entity has been deprecated for instantiation and will become ABSTRACT in a future release; new subtypes should now be used instead. class IfcFlowFitting : public IfcDistributionFlowElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowFitting (IfcAbstractEntity* e); IfcFlowFitting (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -37675,13 +33637,7 @@ public: /// Identifies the predefined types of flow instrument from which the type required may be set. IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum PredefinedType() const; void setPredefinedType(IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcDistributionControlElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcFlowInstrumentTypeEnum; } return IfcDistributionControlElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcDistributionControlElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowInstrumentType (IfcAbstractEntity* e); IfcFlowInstrumentType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum v10_PredefinedType); @@ -37694,13 +33650,7 @@ public: /// IFC 2x4 NOTE: This entity has been deprecated for instantiation and will become ABSTRACT in a future release; new subtypes should now be used instead. class IfcFlowMovingDevice : public IfcDistributionFlowElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowMovingDevice (IfcAbstractEntity* e); IfcFlowMovingDevice (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -37731,13 +33681,7 @@ public: /// Standard representations are defined at the supertype IfcDistrubutionFlowElement. For parametric flow segments where IfcMaterialProfileSetUsage is defined and an 'Axis' representation is defined, then the 'Body' representation may be generated using the 'SweptSolid' or 'AdvancedSweptSolid' representation types by sweeping the profile(s) along the axis. class IfcFlowSegment : public IfcDistributionFlowElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowSegment (IfcAbstractEntity* e); IfcFlowSegment (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -37755,13 +33699,7 @@ public: /// IFC 2x4 NOTE: This entity has been deprecated for instantiation and will become ABSTRACT in a future release; new subtypes should now be used instead. class IfcFlowStorageDevice : public IfcDistributionFlowElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowStorageDevice (IfcAbstractEntity* e); IfcFlowStorageDevice (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -37780,13 +33718,7 @@ public: /// IFC 2x4 NOTE: This entity has been deprecated for instantiation and will become ABSTRACT in a future release; new subtypes should now be used instead. class IfcFlowTerminal : public IfcDistributionFlowElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowTerminal (IfcAbstractEntity* e); IfcFlowTerminal (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -37799,13 +33731,7 @@ public: /// IFC 2x4 NOTE: This entity has been deprecated for instantiation and will become ABSTRACT in a future release; new subtypes should now be used instead. class IfcFlowTreatmentDevice : public IfcDistributionFlowElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowTreatmentDevice (IfcAbstractEntity* e); IfcFlowTreatmentDevice (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -37840,13 +33766,7 @@ public: /// IFC 2x4 change:  Attribute made optional. Type information can be provided by IfcRelDefinesByType and IfcFootingType. IfcFootingTypeEnum::IfcFootingTypeEnum PredefinedType() const; void setPredefinedType(IfcFootingTypeEnum::IfcFootingTypeEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcFootingTypeEnum; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFooting (IfcAbstractEntity* e); IfcFooting (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcFootingTypeEnum::IfcFootingTypeEnum v9_PredefinedType); @@ -38104,13 +34024,7 @@ public: /// IfcRepresentationMap. class IfcMember : public IfcBuildingElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMember (IfcAbstractEntity* e); IfcMember (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -38148,13 +34062,7 @@ public: /// IFC 2x4 change:  Material profile association capability by means of IfcRelAssociatesMaterial has been added. The attribute ConstructionType should not be used whenever its information can be provided by a material profile set, either associated with the IfcPile object or, if present, with a corresponding instance of IfcPileType. IfcPileConstructionEnum::IfcPileConstructionEnum ConstructionType() const; void setConstructionType(IfcPileConstructionEnum::IfcPileConstructionEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcPileTypeEnum; case 9: return Type::IfcPileConstructionEnum; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; case 9: return "ConstructionType"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPile (IfcAbstractEntity* e); IfcPile (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcPileTypeEnum::IfcPileTypeEnum v9_PredefinedType, boost::optional< IfcPileConstructionEnum::IfcPileConstructionEnum > v10_ConstructionType); @@ -38390,13 +34298,7 @@ public: /// IfcRepresentationMap. class IfcPlate : public IfcBuildingElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPlate (IfcAbstractEntity* e); IfcPlate (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -38543,13 +34445,7 @@ public: /// IFC2x PLATFORM CHANGE: The attribute has been changed into an OPTIONAL attribute. IfcRailingTypeEnum::IfcRailingTypeEnum PredefinedType() const; void setPredefinedType(IfcRailingTypeEnum::IfcRailingTypeEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcRailingTypeEnum; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRailing (IfcAbstractEntity* e); IfcRailing (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcRailingTypeEnum::IfcRailingTypeEnum > v9_PredefinedType); @@ -38692,13 +34588,7 @@ class IfcRamp : public IfcBuildingElement { public: IfcRampTypeEnum::IfcRampTypeEnum ShapeType() const; void setShapeType(IfcRampTypeEnum::IfcRampTypeEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcRampTypeEnum; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "ShapeType"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRamp (IfcAbstractEntity* e); IfcRamp (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcRampTypeEnum::IfcRampTypeEnum v9_ShapeType); @@ -38894,13 +34784,7 @@ public: /// Figure 114 — Ramp flight body class IfcRampFlight : public IfcBuildingElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRampFlight (IfcAbstractEntity* e); IfcRampFlight (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -38911,13 +34795,7 @@ class IfcRationalBezierCurve : public IfcBezierCurve { public: std::vector< double > /*[2:?]*/ WeightsData() const; void setWeightsData(std::vector< double > /*[2:?]*/ v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } return IfcBezierCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::UNDEFINED; } return IfcBezierCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "WeightsData"; } return IfcBezierCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRationalBezierCurve (IfcAbstractEntity* e); IfcRationalBezierCurve (int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect, std::vector< double > /*[2:?]*/ v6_WeightsData); @@ -38937,13 +34815,7 @@ public: bool hasSteelGrade() const; std::string SteelGrade() const; void setSteelGrade(std::string v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_STRING; } return IfcBuildingElementComponent::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcLabel; } return IfcBuildingElementComponent::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "SteelGrade"; } return IfcBuildingElementComponent::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcReinforcingElement (IfcAbstractEntity* e); IfcReinforcingElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade); @@ -38995,13 +34867,7 @@ public: void setLongitudinalBarSpacing(double v); double TransverseBarSpacing() const; void setTransverseBarSpacing(double v); - virtual unsigned int getArgumentCount() const { return 17; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_DOUBLE; case 13: return IfcUtil::Argument_DOUBLE; case 14: return IfcUtil::Argument_DOUBLE; case 15: return IfcUtil::Argument_DOUBLE; case 16: return IfcUtil::Argument_DOUBLE; } return IfcReinforcingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcPositiveLengthMeasure; case 10: return Type::IfcPositiveLengthMeasure; case 11: return Type::IfcPositiveLengthMeasure; case 12: return Type::IfcPositiveLengthMeasure; case 13: return Type::IfcAreaMeasure; case 14: return Type::IfcAreaMeasure; case 15: return Type::IfcPositiveLengthMeasure; case 16: return Type::IfcPositiveLengthMeasure; } return IfcReinforcingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "MeshLength"; case 10: return "MeshWidth"; case 11: return "LongitudinalBarNominalDiameter"; case 12: return "TransverseBarNominalDiameter"; case 13: return "LongitudinalBarCrossSectionArea"; case 14: return "TransverseBarCrossSectionArea"; case 15: return "LongitudinalBarSpacing"; case 16: return "TransverseBarSpacing"; } return IfcReinforcingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcReinforcingMesh (IfcAbstractEntity* e); IfcReinforcingMesh (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, boost::optional< double > v10_MeshLength, boost::optional< double > v11_MeshWidth, double v12_LongitudinalBarNominalDiameter, double v13_TransverseBarNominalDiameter, double v14_LongitudinalBarCrossSectionArea, double v15_TransverseBarCrossSectionArea, double v16_LongitudinalBarSpacing, double v17_TransverseBarSpacing); @@ -39156,13 +35022,7 @@ class IfcRoof : public IfcBuildingElement { public: IfcRoofTypeEnum::IfcRoofTypeEnum ShapeType() const; void setShapeType(IfcRoofTypeEnum::IfcRoofTypeEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcRoofTypeEnum; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "ShapeType"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRoof (IfcAbstractEntity* e); IfcRoof (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcRoofTypeEnum::IfcRoofTypeEnum v9_ShapeType); @@ -39175,13 +35035,7 @@ public: bool hasRadius() const; double Radius() const; void setRadius(double v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_DOUBLE; } return IfcEdgeFeature::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcPositiveLengthMeasure; } return IfcEdgeFeature::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "Radius"; } return IfcEdgeFeature::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRoundedEdgeFeature (IfcAbstractEntity* e); IfcRoundedEdgeFeature (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength, boost::optional< double > v10_Radius); @@ -39240,13 +35094,7 @@ public: /// Identifies the predefined types of sensor from which the type required may be set. IfcSensorTypeEnum::IfcSensorTypeEnum PredefinedType() const; void setPredefinedType(IfcSensorTypeEnum::IfcSensorTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcDistributionControlElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcSensorTypeEnum; } return IfcDistributionControlElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcDistributionControlElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSensorType (IfcAbstractEntity* e); IfcSensorType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSensorTypeEnum::IfcSensorTypeEnum v10_PredefinedType); @@ -39522,13 +35370,7 @@ public: /// FC2x PLATFORM CHANGE: The attribute has been changed into an OPTIONAL attribute. IfcSlabTypeEnum::IfcSlabTypeEnum PredefinedType() const; void setPredefinedType(IfcSlabTypeEnum::IfcSlabTypeEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcSlabTypeEnum; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSlab (IfcAbstractEntity* e); IfcSlab (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< IfcSlabTypeEnum::IfcSlabTypeEnum > v9_PredefinedType); @@ -39703,13 +35545,7 @@ class IfcStair : public IfcBuildingElement { public: IfcStairTypeEnum::IfcStairTypeEnum ShapeType() const; void setShapeType(IfcStairTypeEnum::IfcStairTypeEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcStairTypeEnum; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "ShapeType"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStair (IfcAbstractEntity* e); IfcStair (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcStairTypeEnum::IfcStairTypeEnum v9_ShapeType); @@ -39912,13 +35748,7 @@ public: /// IFC2x4 CHANGE The attribute has been deprecated it shall only be exposed with a NIL value. Use Pset_StairFlightCommon.TreadLength instead. double TreadLength() const; void setTreadLength(double v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_INT; case 9: return IfcUtil::Argument_INT; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::UNDEFINED; case 9: return Type::UNDEFINED; case 10: return Type::IfcPositiveLengthMeasure; case 11: return Type::IfcPositiveLengthMeasure; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "NumberOfRiser"; case 9: return "NumberOfTreads"; case 10: return "RiserHeight"; case 11: return "TreadLength"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStairFlight (IfcAbstractEntity* e); IfcStairFlight (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< int > v9_NumberOfRiser, boost::optional< int > v10_NumberOfTreads, boost::optional< double > v11_RiserHeight, boost::optional< double > v12_TreadLength); @@ -39976,13 +35806,7 @@ public: /// References to all result groups available for this structural analysis model. IfcTemplatedEntityList< IfcStructuralResultGroup >::ptr HasResults() const; void setHasResults(IfcTemplatedEntityList< IfcStructuralResultGroup >::ptr v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcSystem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcAnalysisModelTypeEnum; case 6: return Type::IfcAxis2Placement3D; case 7: return Type::IfcStructuralLoadGroup; case 8: return Type::IfcStructuralResultGroup; } return IfcSystem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "PredefinedType"; case 6: return "OrientationOf2DPlane"; case 7: return "LoadedBy"; case 8: return "HasResults"; } return IfcSystem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralAnalysisModel (IfcAbstractEntity* e); IfcStructuralAnalysisModel (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum v6_PredefinedType, IfcAxis2Placement3D* v7_OrientationOf2DPlane, boost::optional< IfcTemplatedEntityList< IfcStructuralLoadGroup >::ptr > v8_LoadedBy, boost::optional< IfcTemplatedEntityList< IfcStructuralResultGroup >::ptr > v9_HasResults); @@ -40017,13 +35841,7 @@ public: bool hasMinCurvatureRadius() const; double MinCurvatureRadius() const; void setMinCurvatureRadius(double v); - virtual unsigned int getArgumentCount() const { return 17; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_DOUBLE; case 13: return IfcUtil::Argument_DOUBLE; case 14: return IfcUtil::Argument_DOUBLE; case 15: return IfcUtil::Argument_DOUBLE; case 16: return IfcUtil::Argument_DOUBLE; } return IfcReinforcingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcTendonTypeEnum; case 10: return Type::IfcPositiveLengthMeasure; case 11: return Type::IfcAreaMeasure; case 12: return Type::IfcForceMeasure; case 13: return Type::IfcPressureMeasure; case 14: return Type::IfcNormalisedRatioMeasure; case 15: return Type::IfcPositiveLengthMeasure; case 16: return Type::IfcPositiveLengthMeasure; } return IfcReinforcingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; case 10: return "NominalDiameter"; case 11: return "CrossSectionArea"; case 12: return "TensionForce"; case 13: return "PreStress"; case 14: return "FrictionCoefficient"; case 15: return "AnchorageSlip"; case 16: return "MinCurvatureRadius"; } return IfcReinforcingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTendon (IfcAbstractEntity* e); IfcTendon (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, IfcTendonTypeEnum::IfcTendonTypeEnum v10_PredefinedType, double v11_NominalDiameter, double v12_CrossSectionArea, boost::optional< double > v13_TensionForce, boost::optional< double > v14_PreStress, boost::optional< double > v15_FrictionCoefficient, boost::optional< double > v16_AnchorageSlip, boost::optional< double > v17_MinCurvatureRadius); @@ -40032,13 +35850,7 @@ public: class IfcTendonAnchor : public IfcReinforcingElement { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcReinforcingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcReinforcingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcReinforcingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTendonAnchor (IfcAbstractEntity* e); IfcTendonAnchor (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade); @@ -40071,13 +35883,7 @@ public: /// Defines the type of vibration isolator. IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum PredefinedType() const; void setPredefinedType(IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcDiscreteAccessoryType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcVibrationIsolatorTypeEnum; } return IfcDiscreteAccessoryType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcDiscreteAccessoryType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcVibrationIsolatorType (IfcAbstractEntity* e); IfcVibrationIsolatorType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum v10_PredefinedType); @@ -40327,13 +36133,7 @@ public: /// IfcRelConnectsPathElements. class IfcWall : public IfcBuildingElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWall (IfcAbstractEntity* e); IfcWall (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -40543,13 +36343,7 @@ public: /// Figure 140 — Wall body clipping curved class IfcWallStandardCase : public IfcWall { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcWall::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcWall::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcWall::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWallStandardCase (IfcAbstractEntity* e); IfcWallStandardCase (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -40929,13 +36723,7 @@ public: /// NOTE  The body of the window might be wider then the window opening (e.g. in cases where the window lining includes a casing). In these cases the OverallWidth shall still be given as the window opening width, and not as the total width of the window lining. double OverallWidth() const; void setOverallWidth(double v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_DOUBLE; case 9: return IfcUtil::Argument_DOUBLE; } return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcPositiveLengthMeasure; case 9: return Type::IfcPositiveLengthMeasure; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "OverallHeight"; case 9: return "OverallWidth"; } return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWindow (IfcAbstractEntity* e); IfcWindow (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_OverallHeight, boost::optional< double > v10_OverallWidth); @@ -40977,13 +36765,7 @@ public: /// Identifies the predefined types of actuator from which the type required may be set. IfcActuatorTypeEnum::IfcActuatorTypeEnum PredefinedType() const; void setPredefinedType(IfcActuatorTypeEnum::IfcActuatorTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcDistributionControlElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcActuatorTypeEnum; } return IfcDistributionControlElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcDistributionControlElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcActuatorType (IfcAbstractEntity* e); IfcActuatorType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcActuatorTypeEnum::IfcActuatorTypeEnum v10_PredefinedType); @@ -41020,13 +36802,7 @@ public: /// Identifies the predefined types of alarm from which the type required may be set. IfcAlarmTypeEnum::IfcAlarmTypeEnum PredefinedType() const; void setPredefinedType(IfcAlarmTypeEnum::IfcAlarmTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcDistributionControlElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcAlarmTypeEnum; } return IfcDistributionControlElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcDistributionControlElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAlarmType (IfcAbstractEntity* e); IfcAlarmType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAlarmTypeEnum::IfcAlarmTypeEnum v10_PredefinedType); @@ -41271,13 +37047,7 @@ public: /// the IfcRepresentationMap. class IfcBeam : public IfcBuildingElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBuildingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBuildingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBeam (IfcAbstractEntity* e); IfcBeam (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -41294,13 +37064,7 @@ public: bool hasHeight() const; double Height() const; void setHeight(double v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; } return IfcEdgeFeature::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcPositiveLengthMeasure; case 10: return Type::IfcPositiveLengthMeasure; } return IfcEdgeFeature::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "Width"; case 10: return "Height"; } return IfcEdgeFeature::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcChamferEdgeFeature (IfcAbstractEntity* e); IfcChamferEdgeFeature (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength, boost::optional< double > v10_Width, boost::optional< double > v11_Height); @@ -41347,13 +37111,7 @@ public: /// Identifies the predefined types of controller from which the type required may be set. IfcControllerTypeEnum::IfcControllerTypeEnum PredefinedType() const; void setPredefinedType(IfcControllerTypeEnum::IfcControllerTypeEnum v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; } return IfcDistributionControlElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcControllerTypeEnum; } return IfcDistributionControlElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcDistributionControlElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcControllerType (IfcAbstractEntity* e); IfcControllerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcControllerTypeEnum::IfcControllerTypeEnum v10_PredefinedType); @@ -41392,13 +37150,7 @@ public: /// 'Wall': The material from which the wall of the duct is constructed. class IfcDistributionChamberElement : public IfcDistributionFlowElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionFlowElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionFlowElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionFlowElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDistributionChamberElement (IfcAbstractEntity* e); IfcDistributionChamberElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag); @@ -41488,14 +37240,8 @@ public: bool hasControlElementId() const; std::string ControlElementId() const; void setControlElementId(std::string v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_STRING; } return IfcDistributionElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcIdentifier; } return IfcDistributionElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "ControlElementId"; } return IfcDistributionElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelFlowControlElements >::ptr AssignedToFlowElement() const; // INVERSE IfcRelFlowControlElements::RelatedControlElements - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelFlowControlElements >::ptr AssignedToFlowElement() const; // INVERSE IfcRelFlowControlElements::RelatedControlElements + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDistributionControlElement (IfcAbstractEntity* e); IfcDistributionControlElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ControlElementId); @@ -41510,13 +37256,7 @@ public: bool hasUserDefinedFunction() const; std::string UserDefinedFunction() const; void setUserDefinedFunction(std::string v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_STRING; } return IfcFlowController::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcElectricDistributionPointFunctionEnum; case 9: return Type::IfcLabel; } return IfcFlowController::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "DistributionPointFunction"; case 9: return "UserDefinedFunction"; } return IfcFlowController::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricDistributionPoint (IfcAbstractEntity* e); IfcElectricDistributionPoint (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum v9_DistributionPointFunction, boost::optional< std::string > v10_UserDefinedFunction); @@ -41566,13 +37306,7 @@ public: bool hasBarSurface() const; IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum BarSurface() const; void setBarSurface(IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum v); - virtual unsigned int getArgumentCount() const { return 14; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_DOUBLE; case 10: return IfcUtil::Argument_DOUBLE; case 11: return IfcUtil::Argument_DOUBLE; case 12: return IfcUtil::Argument_ENUMERATION; case 13: return IfcUtil::Argument_ENUMERATION; } return IfcReinforcingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcPositiveLengthMeasure; case 10: return Type::IfcAreaMeasure; case 11: return Type::IfcPositiveLengthMeasure; case 12: return Type::IfcReinforcingBarRoleEnum; case 13: return Type::IfcReinforcingBarSurfaceEnum; } return IfcReinforcingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "NominalDiameter"; case 10: return "CrossSectionArea"; case 11: return "BarLength"; case 12: return "BarRole"; case 13: return "BarSurface"; } return IfcReinforcingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcReinforcingBar (IfcAbstractEntity* e); IfcReinforcingBar (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, IfcObjectPlacement* v6_ObjectPlacement, IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, double v10_NominalDiameter, double v11_CrossSectionArea, boost::optional< double > v12_BarLength, IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum v13_BarRole, boost::optional< IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum > v14_BarSurface); diff --git a/src/ifcparse/IfcFile.h b/src/ifcparse/IfcFile.h index d40c6023a1..c0d268931d 100644 --- a/src/ifcparse/IfcFile.h +++ b/src/ifcparse/IfcFile.h @@ -41,6 +41,8 @@ public: private: typedef std::map entity_entity_map_t; + const schema_definition* schema_; + bool _create_latebound_entities; entity_by_id_t byid; @@ -131,6 +133,8 @@ public: bool create_latebound_entities() const { return _create_latebound_entities; } std::pair getUnit(IfcSchema::IfcUnitEnum::IfcUnitEnum); + + const schema_definition* schema() const { return schema_; } }; } diff --git a/src/ifcparse/IfcHierarchyHelper.cpp b/src/ifcparse/IfcHierarchyHelper.cpp index d86fe6b7a4..d29e5d716f 100644 --- a/src/ifcparse/IfcHierarchyHelper.cpp +++ b/src/ifcparse/IfcHierarchyHelper.cpp @@ -124,7 +124,7 @@ IfcSchema::IfcProject* IfcHierarchyHelper::addProject(IfcSchema::IfcOwnerHistory void IfcHierarchyHelper::relatePlacements(IfcSchema::IfcProduct* parent, IfcSchema::IfcProduct* product) { IfcSchema::IfcObjectPlacement* place = product->hasObjectPlacement() ? product->ObjectPlacement() : 0; - if (place && place->is(IfcSchema::Type::IfcLocalPlacement)) { + if (place && place->declaration().is(IfcSchema::Type::IfcLocalPlacement)) { IfcSchema::IfcLocalPlacement* local_place = (IfcSchema::IfcLocalPlacement*) place; if (parent->hasObjectPlacement()) { local_place->setPlacementRelTo(parent->ObjectPlacement()); diff --git a/src/ifcparse/IfcLateBoundEntity.cpp b/src/ifcparse/IfcLateBoundEntity.cpp index af13f6d9fd..43d0281498 100644 --- a/src/ifcparse/IfcLateBoundEntity.cpp +++ b/src/ifcparse/IfcLateBoundEntity.cpp @@ -36,10 +36,10 @@ using namespace IfcUtil; IfcWrite::IfcWritableEntity* IfcParse::IfcLateBoundEntity::writable_entity() { IfcWrite::IfcWritableEntity* e; - if (entity->isWritable()) { - e = (IfcWrite::IfcWritableEntity*) entity; + if (data_->isWritable()) { + e = (IfcWrite::IfcWritableEntity*) data_; } else { - entity = e = new IfcWrite::IfcWritableEntity(entity); + data_ = e = new IfcWrite::IfcWritableEntity(data_); } return e; } @@ -47,20 +47,25 @@ IfcParse::IfcLateBoundEntity::IfcLateBoundEntity(const std::string& s) { std::string S = s; for (std::string::iterator i = S.begin(); i != S.end(); ++i ) *i = toupper(*i); _type = IfcSchema::Type::FromString(S); - entity = new IfcWrite::IfcWritableEntity(_type); + data_ = new IfcWrite::IfcWritableEntity(_type); for (unsigned i = 0; i < getArgumentCount(); ++i) { // Side effect of this is that a NULL attribute is created. - entity->getArgument(i); + data_->getArgument(i); } IfcSchema::Type::PopulateDerivedFields(writable_entity()); } IfcParse::IfcLateBoundEntity::IfcLateBoundEntity(IfcAbstractEntity* e) { - entity = e; + data_ = e; _type = e->type(); } +/* +const IfcParse::entity& IfcParse::IfcLateBoundEntity::entity() { + return *get_schema().declaration_by_name(IfcSchema::Type::ToString(_type)); +} +*/ unsigned int IfcParse::IfcLateBoundEntity::id() const { - if (entity->file) { - return static_cast(entity->id()); + if (data_->file) { + return static_cast(data_->id()); } else { throw IfcException("Entity not bound to a file"); } @@ -97,7 +102,7 @@ IfcSchema::Type::Enum IfcParse::IfcLateBoundEntity::getArgumentEntity(unsigned i return IfcSchema::Type::GetAttributeEntity(_type, i); } Argument* IfcParse::IfcLateBoundEntity::getArgument(unsigned int i) const { - return entity->getArgument(i); + return data_->getArgument(i); } const char* IfcParse::IfcLateBoundEntity::getArgumentName(unsigned int i) const { return IfcSchema::Type::GetAttributeName(_type,i).c_str(); @@ -215,11 +220,11 @@ unsigned IfcParse::IfcLateBoundEntity::getArgumentIndex(const std::string& a) co return IfcSchema::Type::GetAttributeIndex(_type,a); } std::string IfcParse::IfcLateBoundEntity::toString() { - return entity->toString(false); + return data_->toString(false); } IfcEntityList::ptr IfcParse::IfcLateBoundEntity::get_inverse(const std::string& a) { std::pair inv = IfcSchema::Type::GetInverseAttribute(_type, a); - return entity->getInverse(inv.first, inv.second); + return data_->getInverse(inv.first, inv.second); } bool IfcParse::IfcLateBoundEntity::is_valid() { const unsigned arg_count = getArgumentCount(); diff --git a/src/ifcparse/IfcLateBoundEntity.h b/src/ifcparse/IfcLateBoundEntity.h index 65a91d0f77..9ae00dea58 100644 --- a/src/ifcparse/IfcLateBoundEntity.h +++ b/src/ifcparse/IfcLateBoundEntity.h @@ -32,7 +32,7 @@ namespace IfcParse { // that in the IfcFile class the distinction what entity type to be created is // no longer necessary and weird diagonal casts when creating geometry from // IfcLateBoundEntities are eliminated. - class IfcLateBoundEntity : public IfcUtil::IfcBaseEntity { + class IfcLateBoundEntity : public IfcUtil::IfcBaseClass { // TODO: -Entity or -Type? private: IfcSchema::Type::Enum _type; IfcWrite::IfcWritableEntity* writable_entity(); @@ -79,6 +79,20 @@ namespace IfcParse { std::string toString(); bool is_valid(); + + // const IfcParse::entity& entity(); + + const IfcAbstractEntity& data() const { return *data_; } + IfcAbstractEntity& data() { return *data_; } + + virtual const IfcParse::declaration& declaration() const { + if (data().file) { + throw; + // data().file-> + } else { + throw; + } + } }; } diff --git a/src/ifcparse/IfcParse.cpp b/src/ifcparse/IfcParse.cpp index 593a512a1b..2162a9ef82 100644 --- a/src/ifcparse/IfcParse.cpp +++ b/src/ifcparse/IfcParse.cpp @@ -37,6 +37,7 @@ #include "../ifcparse/IfcLateBoundEntity.h" #include "../ifcparse/IfcFile.h" #include "../ifcparse/IfcSIPrefix.h" +#include "../ifcparse/IfcSchema.h" using namespace IfcParse; @@ -764,7 +765,7 @@ EntityArgument::operator IfcEntityListList::ptr() const { throw IfcException("Ar unsigned int EntityArgument::size() const { return 1; } Argument* EntityArgument::operator [] (unsigned int i) const { throw IfcException("Argument is not a list of arguments"); } std::string EntityArgument::toString(bool upper) const { - return entity->entity->toString(upper); + return entity->data().toString(upper); } //return entity->entity->toString(); } bool EntityArgument::isNull() const { return false; } @@ -879,11 +880,10 @@ IfcEntityList::ptr Entity::getInverse(IfcSchema::Type::Enum type, int attribute_ } bool Entity::is(IfcSchema::Type::Enum v) const { return _type == v; } -unsigned int Entity::id() { return _id; } +unsigned int Entity::id() const { return _id; } -IfcWrite::IfcWritableEntity* Entity::isWritable() { - return 0; -} +const IfcWrite::IfcWritableEntity* Entity::isWritable() const { return 0; } +IfcWrite::IfcWritableEntity* Entity::isWritable() { return 0; } IfcFile::IfcFile(bool create_latebound_entities) : _create_latebound_entities(create_latebound_entities) @@ -892,6 +892,9 @@ IfcFile::IfcFile(bool create_latebound_entities) , tokens(0) , MaxId(0) { + if (!create_latebound_entities) { + schema_ = &get_schema(); + } setDefaultHeaderValues(); } @@ -961,7 +964,7 @@ bool IfcFile::Init(IfcParse::IfcSpfStream* s) { std::stringstream ss; ss << "\r#" << currentId; Logger::Status(ss.str(), false); } - if ( entity->is(IfcSchema::Type::IfcRoot) ) { + if ( entity->declaration().is(IfcSchema::Type::IfcRoot) ) { IfcSchema::IfcRoot* ifc_root = (IfcSchema::IfcRoot*) entity; try { const std::string guid = ifc_root->GlobalId(); @@ -976,7 +979,7 @@ bool IfcFile::Init(IfcParse::IfcSpfStream* s) { } } - IfcSchema::Type::Enum ty = entity->type(); + IfcSchema::Type::Enum ty = entity->declaration().type(); do { IfcEntityList::ptr instances_by_type = entitiesByType(ty); if (!instances_by_type) { @@ -1031,8 +1034,9 @@ void IfcFile::traverse(IfcUtil::IfcBaseClass* instance, std::set= max_level && max_level > 0) return; - for (unsigned i = 0; i < instance->getArgumentCount(); ++i) { - Argument* arg = instance->getArgument(i); + auto attributes = instance->declaration().as_entity()->all_attributes(); + for (unsigned i = 0; i < attributes.size(); ++i) { + Argument* arg = instance->data().getArgument(i); if (arg->type() == IfcUtil::Argument_ENTITY_INSTANCE) { traverse(*arg, visited, list, level + 1, max_level); @@ -1065,10 +1069,10 @@ void IfcFile::addEntities(IfcEntityList::ptr es) { } } -IfcUtil::IfcBaseClass* IfcFile::addEntity(IfcUtil::IfcBaseClass* entity) { +IfcUtil::IfcBaseClass* IfcFile::addEntity(IfcUtil::IfcBaseClass* instance) { // If this instance has been inserted before, return // a reference to the copy that was created from it. - entity_entity_map_t::iterator it = entity_file_map.find(entity); + entity_entity_map_t::iterator it = entity_file_map.find(instance); if (it != entity_file_map.end()) { return it->second; } @@ -1076,39 +1080,44 @@ IfcUtil::IfcBaseClass* IfcFile::addEntity(IfcUtil::IfcBaseClass* entity) { // Obtain all forward references by a depth-first // traversal and add them to the file. try { - IfcEntityList::ptr entity_attributes = traverse(entity, 1); + IfcEntityList::ptr entity_attributes = traverse(instance, 1); for (IfcEntityList::it it = entity_attributes->begin(); it != entity_attributes->end(); ++it) { - if (*it != entity) { + if (*it != instance) { entity_file_map.insert(entity_entity_map_t::value_type(*it, addEntity(*it))); } } } catch (...) { - Logger::Message(Logger::LOG_ERROR, "Failed to visit forward references of", entity->entity); + Logger::Message(Logger::LOG_ERROR, "Failed to visit forward references of", instance); } // See whether the instance is already part of a file - if (entity->entity->file != 0) { - if (entity->entity->file == this) { + if (instance->data().file != 0) { + if (instance->data().file == this) { // If it is part of this file // nothing needs to be done. - return entity; + return instance; } // An instance is being added from another file. A copy of the - // container and entity is created. The attribute references + // container and instance is created. The attribute references // need to be updated to point to instances in this file. - IfcFile* other_file = entity->entity->file; - IfcWrite::IfcWritableEntity* we = new IfcWrite::IfcWritableEntity(entity->entity); + IfcFile* other_file = instance->data().file; + + // TODO: Proper copy constructor + IfcWrite::IfcWritableEntity* we = new IfcWrite::IfcWritableEntity(&instance->data()); + if (this->create_latebound_entities()) { - entity = new IfcLateBoundEntity(we); + instance = new IfcLateBoundEntity(we); } else { - entity = IfcSchema::SchemaEntity(we); + instance = IfcSchema::SchemaEntity(we); } - // In case an entity is added that contains geometry, the unit + // In case an instance is added that contains geometry, the unit // information needs to be accounted for for IfcLengthMeasures. boost::optional conversion_factor; + const schema_definition* s = schema(); + for (unsigned i = 0; i < we->getArgumentCount(); ++i) { Argument* attr = we->getArgument(i); IfcUtil::ArgumentType attr_type = attr->type(); @@ -1138,23 +1147,31 @@ IfcUtil::IfcBaseClass* IfcFile::addEntity(IfcUtil::IfcBaseClass* entity) { new_instances->push(list); } we->setArgument(i, new_instances); - } else if (entity->getArgumentEntity(i) == IfcSchema::Type::IfcLengthMeasure || - entity->getArgumentEntity(i) == IfcSchema::Type::IfcPositiveLengthMeasure) - { - if (!conversion_factor) { - conversion_factor = other_file->getUnit(IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT).second / - getUnit(IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT).second; - } - if (attr_type == IfcUtil::Argument_DOUBLE) { - double v = *attr; - v *= *conversion_factor; - we->setArgument(i, v); - } else if (attr_type == IfcUtil::Argument_AGGREGATE_OF_DOUBLE) { - std::vector v = *attr; - for (std::vector::iterator it = v.begin(); it != v.end(); ++it) { - (*it) *= *conversion_factor; + } else if (s) { + const entity* e = instance->declaration().as_entity(); + if (e) { + const std::vector attrs = e->all_attributes(); + const parameter_type* pt = attrs[i]->type_of_attribute(); + while (pt->as_aggregation_type()) { + pt = pt->as_aggregation_type()->type_of_element(); + } + if (pt->is(IfcSchema::Type::IfcLengthMeasure)) { + if (!conversion_factor) { + conversion_factor = other_file->getUnit(IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT).second / + getUnit(IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT).second; + } + if (attr_type == IfcUtil::Argument_DOUBLE) { + double v = *attr; + v *= *conversion_factor; + we->setArgument(i, v); + } else if (attr_type == IfcUtil::Argument_AGGREGATE_OF_DOUBLE) { + std::vector v = *attr; + for (std::vector::iterator it = v.begin(); it != v.end(); ++it) { + (*it) *= *conversion_factor; + } + we->setArgument(i, v); + } } - we->setArgument(i, v); } } } @@ -1166,13 +1183,13 @@ IfcUtil::IfcBaseClass* IfcFile::addEntity(IfcUtil::IfcBaseClass* entity) { } // For subtypes of IfcRoot, the GUID mapping needs to be updated. - if (entity->is(IfcSchema::Type::IfcRoot)) { - IfcSchema::IfcRoot* ifc_root = (IfcSchema::IfcRoot*) entity; + if (instance->declaration().is(IfcSchema::Type::IfcRoot)) { + IfcSchema::IfcRoot* ifc_root = (IfcSchema::IfcRoot*) instance; try { const std::string guid = ifc_root->GlobalId(); if ( byguid.find(guid) != byguid.end() ) { std::stringstream ss; - ss << "Overwriting entity with guid " << guid; + ss << "Overwriting instance with guid " << guid; Logger::Message(Logger::LOG_WARNING,ss.str()); } byguid[guid] = ifc_root; @@ -1181,74 +1198,75 @@ IfcUtil::IfcBaseClass* IfcFile::addEntity(IfcUtil::IfcBaseClass* entity) { } } - // The mapping by entity type is updated. - IfcSchema::Type::Enum ty = entity->type(); + // The mapping by instance type is updated. + IfcSchema::Type::Enum ty = instance->declaration().type(); do { IfcEntityList::ptr instances_by_type = entitiesByType(ty); if (!instances_by_type) { instances_by_type = IfcEntityList::ptr(new IfcEntityList()); bytype[ty] = instances_by_type; } - instances_by_type->push(entity); + instances_by_type->push(instance); ty = IfcSchema::Type::Parent(ty); } while ( ty > -1 ); int new_id = -1; - if (entity->entity->isWritable() && !entity->entity->file) { + if (instance->data().isWritable() && !instance->data().file) { // For newly created entities ensure a valid ENTITY_INSTANCE_NAME is set - entity->entity->file = this; - new_id = entity->entity->isWritable()->setId(); + instance->data().file = this; + new_id = instance->data().isWritable()->setId(); } else { - new_id = entity->entity->id(); + new_id = instance->data().id(); } if (byid.find(new_id) != byid.end()) { // This should not happen std::stringstream ss; - ss << "Overwriting entity with id " << new_id; + ss << "Overwriting instance with id " << new_id; Logger::Message(Logger::LOG_WARNING, ss.str()); } // The mapping by entity instance name is updated. - byid[new_id] = entity; + byid[new_id] = instance; // The mapping by reference is updated. IfcEntityList::ptr entity_attributes(new IfcEntityList); try { - entity_attributes = traverse(entity, 1); + entity_attributes = traverse(instance, 1); } catch (...) {} for (IfcEntityList::it it = entity_attributes->begin(); it != entity_attributes->end(); ++it) { IfcUtil::IfcBaseClass* entity_attribute = *it; - if (*it == entity) continue; + if (*it == instance) continue; try { - if (!IfcSchema::Type::IsSimple(entity_attribute->type())) { - unsigned entity_attribute_id = entity_attribute->entity->id(); + // if (!IfcSchema::Type::IsSimple(entity_attribute->type())) { + if (!entity_attribute->declaration().as_entity()) { + unsigned entity_attribute_id = entity_attribute->data().id(); IfcEntityList::ptr refs = entitiesByReference(entity_attribute_id); if (!refs) { refs = IfcEntityList::ptr(new IfcEntityList); byref[entity_attribute_id] = refs; } - refs->push(entity); + refs->push(instance); } } catch (const IfcParse::IfcException&) {} } - return entity; + return instance; } IfcWrite::IfcWritableEntity* make_writable(IfcUtil::IfcBaseClass* instance) { - if (instance->entity->isWritable()) { - return instance->entity->isWritable(); + if (instance->data().isWritable()) { + return instance->data().isWritable(); } - IfcWrite::IfcWritableEntity* return_value; - instance->entity = return_value = new IfcWrite::IfcWritableEntity(instance->entity); + IfcWrite::IfcWritableEntity* return_value = new IfcWrite::IfcWritableEntity(&instance->data()); + instance->data(return_value); return return_value; } -void IfcFile::removeEntity(IfcUtil::IfcBaseClass* entity) { - const unsigned id = entity->entity->id(); - IfcUtil::IfcBaseClass* file_entity = entityById(id); +void IfcFile::removeEntity(IfcUtil::IfcBaseClass* instance) { + const unsigned id = instance->data().id(); + IfcUtil::IfcBaseClass* file_instance = entityById(id); // TODO: Create a set of weak relations. Inverse relations that do not dictate an // instance to be retained. For example: when deleting an IfcRepresentation, the @@ -1257,38 +1275,40 @@ void IfcFile::removeEntity(IfcUtil::IfcBaseClass* entity) { // characterized as weak. std::set weak_roots; - if (entity != file_entity) { + if (instance != file_instance) { throw IfcParse::IfcException("Instance not part of this file"); } std::set deletion_queue; IfcEntityList::ptr references = entitiesByReference(id); - // Alter entity instances with INVERSE relations to the entity being + // Alter entity instances with INVERSE relations to the instance being // deleted. This is necessary to maintain a valid IFC file, because // dangling references to it's entities name should be removed. At this // moment, inversely related instances affected by the removal of the - // entity being deleted are not deleted themselves. + // instance being deleted are not deleted themselves. if (references) { for (IfcEntityList::it it = references->begin(); it != references->end(); ++it) { IfcUtil::IfcBaseEntity* related_instance = (IfcUtil::IfcBaseEntity*) *it; - for (unsigned i = 0; i < related_instance->getArgumentCount(); ++i) { - Argument* attr = related_instance->getArgument(i); + for (unsigned i = 0; i < related_instance->data().getArgumentCount(); ++i) { + + Argument* attr = related_instance->data().getArgument(i); if (attr->isNull()) continue; - IfcUtil::ArgumentType attr_type = related_instance->getArgumentType(i); + IfcUtil::ArgumentType attr_type = attr->type(); + switch(attr_type) { case IfcUtil::Argument_ENTITY_INSTANCE: { IfcUtil::IfcBaseClass* instance_attribute = *attr; - if (instance_attribute == entity) { + if (instance_attribute == instance) { make_writable(related_instance)->setArgument(i); // deletion_queue.insert(related_instance); } } break; case IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE: { IfcEntityList::ptr instance_list = *attr; - if (instance_list->contains(entity)) { - instance_list->remove(entity); + if (instance_list->contains(instance)) { + instance_list->remove(instance); make_writable(related_instance)->setArgument(i, instance_list); /* if (instance_list->size() == 0) { deletion_queue.insert(related_instance); @@ -1297,12 +1317,12 @@ void IfcFile::removeEntity(IfcUtil::IfcBaseClass* entity) { break; case IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE: { IfcEntityListList::ptr instance_list_list = *attr; - if (instance_list_list->contains(entity)) { + if (instance_list_list->contains(instance)) { IfcEntityListList::ptr new_list(new IfcEntityListList); for (IfcEntityListList::outer_it it = instance_list_list->begin(); it != instance_list_list->end(); ++it) { std::vector instances = *it; std::vector::iterator jt; - while ((jt = std::find(instances.begin(), instances.end(), entity)) != instances.end()) { + while ((jt = std::find(instances.begin(), instances.end(), instance)) != instances.end()) { instances.erase(jt); } new_list->push(instances); @@ -1320,33 +1340,33 @@ void IfcFile::removeEntity(IfcUtil::IfcBaseClass* entity) { byref.erase(byref.find(id)); } - IfcEntityList::ptr entity_attributes = traverse(entity, 1); - for (IfcEntityList::it it = entity_attributes->begin(); it != entity_attributes->end(); ++it) { - IfcUtil::IfcBaseClass* entity_attribute = *it; - if (entity_attribute == entity) continue; - entitiesByReference(entity_attribute->entity->id())->remove(entity); - if (entitiesByReference(entity_attribute->entity->id())->filtered(weak_roots)->size() == 0) { - deletion_queue.insert(entity_attribute); + IfcEntityList::ptr instance_attributes = traverse(instance, 1); + for (IfcEntityList::it it = instance_attributes->begin(); it != instance_attributes->end(); ++it) { + IfcUtil::IfcBaseClass* instance_attribute = *it; + if (instance_attribute == instance) continue; + entitiesByReference(instance_attribute->data().id())->remove(instance); + if (entitiesByReference(instance_attribute->data().id())->filtered(weak_roots)->size() == 0) { + deletion_queue.insert(instance_attribute); } } - if (entity->is(IfcSchema::Type::IfcRoot)) { - const std::string global_id = ((IfcSchema::IfcRoot*) entity)->GlobalId(); + IfcSchema::IfcRoot* root = instance->as(); + if (root) { + const std::string global_id = root->GlobalId(); byguid.erase(byguid.find(global_id)); } byid.erase(byid.find(id)); - IfcEntityList::ptr instances_of_same_type = entitiesByType(entity->type()); - instances_of_same_type->remove(entity); + IfcEntityList::ptr instances_of_same_type = entitiesByType(instance->declaration().type()); + instances_of_same_type->remove(instance); while (!deletion_queue.empty()) { removeEntity(*deletion_queue.begin()); deletion_queue.erase(deletion_queue.begin()); } - delete entity->entity; - delete entity; + delete instance; } IfcEntityList::ptr IfcFile::entitiesByType(IfcSchema::Type::Enum t) { @@ -1385,7 +1405,6 @@ IfcSchema::IfcRoot* IfcFile::entityByGuid(const std::string& guid) { // FIXME: Test destructor to delete entity and arg allocations IfcFile::~IfcFile() { for( entity_by_id_t::const_iterator it = byid.begin(); it != byid.end(); ++ it ) { - delete it->second->entity; delete it->second; } delete stream; @@ -1405,8 +1424,8 @@ std::ostream& operator<< (std::ostream& os, const IfcParse::IfcFile& f) { for ( IfcFile::entity_by_id_t::const_iterator it = f.begin(); it != f.end(); ++ it ) { const IfcUtil::IfcBaseClass* e = it->second; - if (!IfcSchema::Type::IsSimple(e->type())) { - os << e->entity->toString(true) << ";" << std::endl; + if (!IfcSchema::Type::IsSimple(e->data().type())) { + os << e->data().toString(true) << ";" << std::endl; } } @@ -1440,9 +1459,9 @@ IfcEntityList::ptr IfcFile::getInverse(int instance_id, IfcSchema::Type::Enum ty if (!all) return l; for(IfcEntityList::it it = all->begin(); it != all->end(); ++it) { - bool valid = type == IfcSchema::Type::UNDEFINED || (*it)->is(type); + bool valid = type == IfcSchema::Type::UNDEFINED || (*it)->declaration().is(type); if (valid && attribute_index >= 0) { - Argument* arg = (*it)->entity->getArgument(attribute_index); + Argument* arg = (*it)->data().getArgument(attribute_index); if (arg->type() == IfcUtil::Argument_ENTITY_INSTANCE) { valid = instance == *arg; } else if (arg->type() == IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE) { @@ -1490,21 +1509,21 @@ std::pair IfcFile::getUnit(IfcSchema::IfcUnitE IfcEntityList::ptr units = project->UnitsInContext()->Units(); for (IfcEntityList::it it = units->begin(); it != units->end(); ++it) { IfcSchema::IfcUnit* unit = *it; - if (unit->is(IfcSchema::Type::IfcNamedUnit)) { + if (unit->declaration().is(IfcSchema::Type::IfcNamedUnit)) { IfcSchema::IfcNamedUnit* named_unit = (IfcSchema::IfcNamedUnit*) unit; if (named_unit->UnitType() != type) { continue; } IfcSchema::IfcSIUnit* unit = 0; - if (named_unit->is(IfcSchema::Type::IfcConversionBasedUnit)) { + if (named_unit->declaration().is(IfcSchema::Type::IfcConversionBasedUnit)) { IfcSchema::IfcConversionBasedUnit* u = (IfcSchema::IfcConversionBasedUnit*)named_unit; IfcSchema::IfcMeasureWithUnit* mu = u->ConversionFactor(); - return_value.second *= static_cast(*mu->ValueComponent()->entity->getArgument(0)); + return_value.second *= static_cast(*mu->ValueComponent()->data().getArgument(0)); return_value.first = named_unit; - if (mu->UnitComponent()->is(IfcSchema::Type::IfcSIUnit)) { + if (mu->UnitComponent()->declaration().is(IfcSchema::Type::IfcSIUnit)) { unit = (IfcSchema::IfcSIUnit*) mu->UnitComponent(); } - } else if (named_unit->is(IfcSchema::Type::IfcSIUnit)) { + } else if (named_unit->declaration().is(IfcSchema::Type::IfcSIUnit)) { return_value.first = unit = (IfcSchema::IfcSIUnit*) named_unit; } if (unit) { diff --git a/src/ifcparse/IfcParse.h b/src/ifcparse/IfcParse.h index 785e93f1f5..6ba81834d0 100644 --- a/src/ifcparse/IfcParse.h +++ b/src/ifcparse/IfcParse.h @@ -257,7 +257,8 @@ namespace IfcParse { std::string datatype() const; IfcSchema::Type::Enum type() const; bool is(IfcSchema::Type::Enum v) const; - unsigned int id(); + unsigned int id() const; + const IfcWrite::IfcWritableEntity* isWritable() const; IfcWrite::IfcWritableEntity* isWritable(); }; diff --git a/src/ifcparse/IfcSchema.cpp b/src/ifcparse/IfcSchema.cpp new file mode 100644 index 0000000000..c56fe1b196 --- /dev/null +++ b/src/ifcparse/IfcSchema.cpp @@ -0,0 +1,21 @@ +#include "IfcSchema.h" + +bool IfcParse::declaration::is(const std::string& name) const { + return is(IfcSchema::Type::FromString(name)); +} + +bool IfcParse::declaration::is(IfcSchema::Type::Enum name) const { + if (this->as_entity()) { + return this->as_entity()->is(name); + } else { + return this->name() == IfcSchema::Type::ToString(name); + } +} + +bool IfcParse::named_type::is(const std::string& name) const { + return declared_type()->is(name); +} + +bool IfcParse::named_type::is(IfcSchema::Type::Enum name) const { + return declared_type()->is(name); +} \ No newline at end of file diff --git a/src/ifcparse/IfcSchema.h b/src/ifcparse/IfcSchema.h index 75adf4c541..4edc9ba6ab 100644 --- a/src/ifcparse/IfcSchema.h +++ b/src/ifcparse/IfcSchema.h @@ -24,222 +24,295 @@ #include #include -class declaration; -class type_declaration; -class select_type; -class enumeration_type; -class entity; +#ifdef USE_IFC4 +#include "../ifcparse/Ifc4enum.h" +#else +#include "../ifcparse/Ifc2x3enum.h" +#endif -class parameter_type { -}; +namespace IfcParse { -class named_type : public parameter_type { -protected: - declaration* declared_type_; -public: - named_type(declaration* declared_type) - : declared_type_(declared_type) {} + class declaration; + + class type_declaration; + class select_type; + class enumeration_type; + class entity; - declaration* declared_type() const { return declared_type_; } -}; + class named_type; + class simple_type; + class aggregation_type; -class simple_type : public parameter_type { -public: - typedef enum { binary_type, boolean_type, integer_type, logical_type, number_type, real_type, string_type } data_type; -protected: - data_type declared_type_; -public: - simple_type(data_type declared_type) - : declared_type_(declared_type) {} + class parameter_type { + public: + virtual const named_type* as_named_type() const { return static_cast(0); } + virtual const simple_type* as_simple_type() const { return static_cast(0); } + virtual const aggregation_type* as_aggregation_type() const { return static_cast(0); } - data_type declared_type() const { return declared_type_; } -}; + virtual bool is(const std::string& name) const { return false; } + virtual bool is(IfcSchema::Type::Enum name) const { return false; } + }; -class aggregation_type : public parameter_type { -public: - typedef enum { array_type, bag_type, list_type, set_type } aggregate_type; -protected: - aggregate_type type_of_aggregation_; - int bound1_, bound2_; - parameter_type* type_of_element_; -public: - aggregation_type(aggregate_type type_of_aggregation, int bound1, int bound2, parameter_type* type_of_element) - : type_of_aggregation_(type_of_aggregation) - , bound1_(bound1) - , bound2_(bound2) - , type_of_element_(type_of_element) - {} - - aggregate_type type_of_aggregation() const { type_of_aggregation_; } - int bound1() const { return bound1_; } - int bound2() const { return bound2_; } - parameter_type* type_of_element() const { return type_of_element_; } -}; - -class declaration { -protected: - std::string name_; - -public: - declaration(const std::string& name) - : name_(name) {} - - const std::string& name() const { return name_; } - - virtual const type_declaration* as_type_declaration() const { return static_cast(0); } - virtual const select_type* as_select_type() const { return static_cast(0); } - virtual const enumeration_type* as_enumeration_type() const { return static_cast(0); } - virtual const entity* as_entity() const { return static_cast(0); } -}; - -class type_declaration : public declaration { -protected: - const parameter_type* declared_type_; - -public: - type_declaration(const std::string& name, const parameter_type* declared_type) - : declaration(name) - , declared_type_(declared_type) {} - - const parameter_type* declared_type() const { return declared_type_; } - - virtual const type_declaration* as_type_declaration() const { return this; } -}; - -class select_type : public declaration { -protected: - std::vector select_list_; -public: - select_type(const std::string& name, const std::vector& select_list) - : declaration(name) - , select_list_(select_list) {} - - const std::vector& select_list() const { return select_list_; } - - virtual const select_type* as_select_type() const { return this; } -}; - -class enumeration_type : public declaration { -protected: - std::vector enumeration_items_; -public: - enumeration_type(const std::string& name, const std::vector& enumeration_items) - : declaration(name) - , enumeration_items_(enumeration_items) {} - - const std::vector& enumeration_items() const { return enumeration_items_; } - - virtual const enumeration_type* as_enumeration_type() const { return this; } -}; - -class entity : public declaration { -public: - class attribute { + class named_type : public parameter_type { protected: + declaration* declared_type_; + public: + named_type(declaration* declared_type) + : declared_type_(declared_type) {} + + declaration* declared_type() const { return declared_type_; } + + virtual const named_type* as_named_type() const { return this; } + + virtual bool is(const std::string& name) const; + virtual bool is(IfcSchema::Type::Enum name) const; + }; + + class simple_type : public parameter_type { + public: + typedef enum { binary_type, boolean_type, integer_type, logical_type, number_type, real_type, string_type } data_type; + protected: + data_type declared_type_; + public: + simple_type(data_type declared_type) + : declared_type_(declared_type) {} + + data_type declared_type() const { return declared_type_; } + + virtual const simple_type* as_simple_type() const { return this; } + }; + + class aggregation_type : public parameter_type { + public: + typedef enum { array_type, bag_type, list_type, set_type } aggregate_type; + protected: + aggregate_type type_of_aggregation_; + int bound1_, bound2_; + parameter_type* type_of_element_; + public: + aggregation_type(aggregate_type type_of_aggregation, int bound1, int bound2, parameter_type* type_of_element) + : type_of_aggregation_(type_of_aggregation) + , bound1_(bound1) + , bound2_(bound2) + , type_of_element_(type_of_element) + {} + + aggregate_type type_of_aggregation() const { type_of_aggregation_; } + int bound1() const { return bound1_; } + int bound2() const { return bound2_; } + parameter_type* type_of_element() const { return type_of_element_; } + + virtual const aggregation_type* as_aggregation_type() const { return this; } + }; + + class declaration { + protected: + // std::string name_; + IfcSchema::Type::Enum name_; + + public: + declaration(IfcSchema::Type::Enum name) + : name_(name) {} + declaration(const std::string& name) + : name_(IfcSchema::Type::FromString(name)) {} + + std::string name() const { return IfcSchema::Type::ToString(name_); } + + virtual const type_declaration* as_type_declaration() const { return static_cast(0); } + virtual const select_type* as_select_type() const { return static_cast(0); } + virtual const enumeration_type* as_enumeration_type() const { return static_cast(0); } + virtual const entity* as_entity() const { return static_cast(0); } + + // TODO: Type checking by Enum value + bool is(const std::string& name) const; + bool is(IfcSchema::Type::Enum name) const; + + IfcSchema::Type::Enum type() const { + return name_; + } + }; + + class type_declaration : public declaration { + protected: + const parameter_type* declared_type_; + + public: + type_declaration(const std::string& name, const parameter_type* declared_type) + : declaration(name) + , declared_type_(declared_type) {} + type_declaration(IfcSchema::Type::Enum name, const parameter_type* declared_type) + : declaration(name) + , declared_type_(declared_type) {} + + const parameter_type* declared_type() const { return declared_type_; } + + virtual const type_declaration* as_type_declaration() const { return this; } + }; + + class select_type : public declaration { + protected: + std::vector select_list_; + public: + select_type(const std::string& name, const std::vector& select_list) + : declaration(name) + , select_list_(select_list) {} + select_type(IfcSchema::Type::Enum name, const std::vector& select_list) + : declaration(name) + , select_list_(select_list) {} + + const std::vector& select_list() const { return select_list_; } + + virtual const select_type* as_select_type() const { return this; } + }; + + class enumeration_type : public declaration { + protected: + std::vector enumeration_items_; + public: + enumeration_type(const std::string& name, const std::vector& enumeration_items) + : declaration(name) + , enumeration_items_(enumeration_items) {} + enumeration_type(IfcSchema::Type::Enum name, const std::vector& enumeration_items) + : declaration(name) + , enumeration_items_(enumeration_items) {} + + const std::vector& enumeration_items() const { return enumeration_items_; } + + virtual const enumeration_type* as_enumeration_type() const { return this; } + }; + + class entity : public declaration { + public: + class attribute { + protected: + std::string name_; + const parameter_type* type_of_attribute_; + bool optional_; + + public: + attribute(const std::string& name, parameter_type* type_of_attribute, bool optional) + : name_(name) + , type_of_attribute_(type_of_attribute) + , optional_(optional) {} + + const std::string& name() const { return name_; } + const parameter_type* type_of_attribute() const { return type_of_attribute_; } + bool optional() const { return optional_; } + }; + + protected: + const entity* supertype_; /* NB: IFC explicitly allows only single inheritance */ + std::vector subtypes_; + + std::vector attributes_; + std::vector derived_; + + public: + entity(const std::string& name, entity* supertype) + : declaration(name) + , supertype_(supertype) + {} + entity(IfcSchema::Type::Enum name, entity* supertype) + : declaration(name) + , supertype_(supertype) + {} + + bool is(const std::string& name) const { + return is(IfcSchema::Type::FromString(name)); + } + + bool is(IfcSchema::Type::Enum name) const { + if (name == name_) return true; + else if (supertype_) return supertype_->is(name); + else return false; + } + + void set_subtypes(const std::vector& subtypes) { + subtypes_ = subtypes; + } + + void set_attributes(const std::vector& attributes, const std::vector& derived) { + attributes_ = attributes; + derived_ = derived; + } + + const std::vector& subtypes() const { return subtypes_; } + const std::vector& attributes() const { return attributes_; } + const std::vector& derived() const { return derived_; } + + const std::vector all_attributes() const { + std::vector attrs; + attrs.reserve(derived_.size()); + std::vector::iterator it = attrs.begin(); + if (supertype_) { + const std::vector supertype_attrs = supertype_->all_attributes(); + it = std::copy(supertype_attrs.begin(), supertype_attrs.end(), it); + } + std::copy(attributes_.begin(), attributes_.end(), it); + return attrs; + } + + virtual const entity* as_entity() const { return this; } + }; + + class schema_definition { + private: + bool built_in_; + std::string name_; - const parameter_type* type_of_attribute_; - bool optional_; + + std::vector declarations_; + + std::vector type_declarations_; + std::vector select_types_; + std::vector enumeration_types_; + + class declaration_by_name_cmp : public std::binary_function { + public: + bool operator()(const declaration* decl, const std::string& name) { + return decl->name() < name; + } + }; public: - attribute(const std::string& name, parameter_type* type_of_attribute, bool optional) + schema_definition(const std::string& name, const std::vector& declarations, const bool built_in = false) : name_(name) - , type_of_attribute_(type_of_attribute) - , optional_(optional) {} + , declarations_(declarations) + , built_in_(built_in) + { + for (std::vector::const_iterator it = declarations_.begin(); it != declarations_.end(); ++it) { + if ((**it).as_type_declaration()) type_declarations_.push_back((**it).as_type_declaration()); + if ((**it).as_select_type()) select_types_.push_back((**it).as_select_type()); + if ((**it).as_enumeration_type()) enumeration_types_.push_back((**it).as_enumeration_type()); + } + } - const std::string& name() const { return name_; } - const parameter_type* type_of_attribute() const { return type_of_attribute_; } - bool optional() const { return optional_; } + ~schema_definition() { + for (std::vector::const_iterator it = declarations_.begin(); it != declarations_.end(); ++it) { + delete *it; + } + } + + const declaration* declaration_by_name(const std::string& name) const { + std::vector::const_iterator it = std::lower_bound(declarations_.begin(), declarations_.end(), name, declaration_by_name_cmp()); + if (it == declarations_.end() || (**it).name() != name) { + throw; + } else { + return *it; + } + } + + const declaration* declaration_by_name(IfcSchema::Type::Enum name) const { + if (!built_in_) throw; + return declaration_by_name(IfcSchema::Type::ToString(name)); + } + + const std::vector& declarations() { return declarations_; } + const std::vector& type_declarations() { return type_declarations_; } + const std::vector& select_types() { return select_types_; } + const std::vector& enumeration_types() { return enumeration_types_; } }; -protected: - const entity* supertype_; /* NB: IFC explicitly allows only single inheritance */ - std::vector subtypes_; +} - std::vector attributes_; - std::vector derived_; - -public: - entity(const std::string& name, entity* supertype) - : declaration(name) - , supertype_(supertype) - {} - - void set_subtypes(const std::vector& subtypes) { - subtypes_ = subtypes; - } - - void set_attributes(const std::vector& attributes, const std::vector& derived) { - attributes_ = attributes; - derived_ = derived; - } - - const std::vector& subtypes() const { return subtypes_; } - const std::vector& attributes() const { return attributes_; } - const std::vector& derived() const { return derived_; } - - const std::vector all_attributes() const { - std::vector attrs; - attrs.reserve(derived_.size()); - std::vector::iterator it = attrs.begin(); - if (supertype_) { - const std::vector supertype_attrs = supertype_->all_attributes(); - it = std::copy(supertype_attrs.begin(), supertype_attrs.end(), it); - } - std::copy(attributes_.begin(), attributes_.end(), it); - return attrs; - } - - virtual const entity* as_entity() const { return this; } -}; - -class schema_definition { -private: - std::string name_; - - std::vector declarations_; - - std::vector type_declarations_; - std::vector select_types_; - std::vector enumeration_types_; - - class declaration_by_name_cmp : public std::binary_function { - public: - bool operator()(const declaration* decl, const std::string& name) { - return decl->name() < name; - } - }; - -public: - schema_definition(const std::string& name, const std::vector& declarations) - : name_(name) - , declarations_(declarations) - { - for (std::vector::const_iterator it = declarations_.begin(); it != declarations_.end(); ++it) { - if ((**it).as_type_declaration()) type_declarations_.push_back((**it).as_type_declaration()); - if ((**it).as_select_type()) select_types_.push_back((**it).as_select_type()); - if ((**it).as_enumeration_type()) enumeration_types_.push_back((**it).as_enumeration_type()); - } - } - - ~schema_definition() { - for (std::vector::const_iterator it = declarations_.begin(); it != declarations_.end(); ++it) { - delete *it; - } - } - - const declaration* declaration_by_name(const std::string& name) { - std::vector::const_iterator it = std::lower_bound(declarations_.begin(), declarations_.end(), name, declaration_by_name_cmp()); - if (it == declarations_.end() || (**it).name() != name) { - throw; - } else { - return *it; - } - } - - const std::vector& declarations() { return declarations_; } - const std::vector& type_declarations() { return type_declarations_; } - const std::vector& select_types() { return select_types_; } - const std::vector& enumeration_types() { return enumeration_types_; } -}; - -#endif \ No newline at end of file +#endif diff --git a/src/ifcparse/IfcSpfHeader.h b/src/ifcparse/IfcSpfHeader.h index 9edce30ea9..fe118bdbc6 100644 --- a/src/ifcparse/IfcSpfHeader.h +++ b/src/ifcparse/IfcSpfHeader.h @@ -91,7 +91,11 @@ public: return ss.str(); } - unsigned int id() { + unsigned int id() const { + return 0; + } + + const IfcWrite::IfcWritableEntity* isWritable() const { return 0; } diff --git a/src/ifcparse/IfcUtil.cpp b/src/ifcparse/IfcUtil.cpp index 0f4bc13734..5320d8f41e 100644 --- a/src/ifcparse/IfcUtil.cpp +++ b/src/ifcparse/IfcUtil.cpp @@ -56,7 +56,7 @@ IfcEntityList::ptr IfcEntityList::filtered(const std::set for (it it = begin(); it != end(); ++it) { bool contained = false; for (std::set::const_iterator jt = entities.begin(); jt != entities.end(); ++jt) { - if ((*it)->is(*jt)) { + if ((*it)->declaration().is(*jt)) { contained = true; break; } @@ -69,9 +69,9 @@ IfcEntityList::ptr IfcEntityList::filtered(const std::set } -unsigned int IfcUtil::IfcBaseType::getArgumentCount() const { return 1; } -Argument* IfcUtil::IfcBaseType::getArgument(unsigned int i) const { return entity->getArgument(i); } -const char* IfcUtil::IfcBaseType::getArgumentName(unsigned int i) const { if (i == 0) { return "wrappedValue"; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } +// unsigned int IfcUtil::IfcBaseType::getArgumentCount() const { return 1; } +// Argument* IfcUtil::IfcBaseType::getArgument(unsigned int i) const { return entity->getArgument(i); } +// const char* IfcUtil::IfcBaseType::getArgumentName(unsigned int i) const { if (i == 0) { return "wrappedValue"; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } void Logger::SetOutput(std::ostream* l1, std::ostream* l2) { log1 = l1; @@ -80,10 +80,10 @@ void Logger::SetOutput(std::ostream* l1, std::ostream* l2) { log2 = &log_stream; } } -void Logger::Message(Logger::Severity type, const std::string& message, IfcAbstractEntity* entity) { +void Logger::Message(Logger::Severity type, const std::string& message, const IfcUtil::IfcBaseClass* entity) { if ( log2 && type >= verbosity ) { (*log2) << "[" << severity_strings[type] << "] " << message << std::endl; - if ( entity ) (*log2) << entity->toString() << std::endl; + if ( entity ) (*log2) << entity->data().toString() << std::endl; } } void Logger::Status(const std::string& message, bool new_line) { @@ -143,4 +143,13 @@ bool IfcUtil::valid_binary_string(const std::string& s) { if (*it != '0' && *it != '1') return false; } return true; +} + +IfcUtil::IfcBaseClass::~IfcBaseClass() { + delete data_; +} + +void IfcUtil::IfcBaseClass::data(IfcAbstractEntity* d) { + delete data_; + data_ = d; } \ No newline at end of file diff --git a/src/ifcparse/IfcUtil.h b/src/ifcparse/IfcUtil.h index e57f5da279..bbacfe9461 100644 --- a/src/ifcparse/IfcUtil.h +++ b/src/ifcparse/IfcUtil.h @@ -28,6 +28,7 @@ #include +#include "../ifcparse/IfcSchema.h" #include "../ifcparse/SharedPointer.h" #ifdef USE_IFC4 @@ -40,6 +41,13 @@ class Argument; class IfcEntityList; class IfcEntityListList; class IfcAbstractEntity; + +namespace IfcParse { // these have to be declared first in order for the virtual function below to be covariant. separate into different header file + class declaration; + class entity; + class type_declaration; +} + namespace IfcWrite { class IfcWritableEntity; } @@ -72,35 +80,53 @@ namespace IfcUtil { const char* ArgumentTypeToString(ArgumentType argument_type); class IfcBaseClass { + protected: + IfcAbstractEntity* data_; public: - IfcAbstractEntity* entity; - virtual bool is(IfcSchema::Type::Enum v) const = 0; - virtual IfcSchema::Type::Enum type() const = 0; + IfcBaseClass() : data_(0) {} + IfcBaseClass(IfcAbstractEntity* d) : data_(d) {} + virtual ~IfcBaseClass(); - virtual unsigned int getArgumentCount() const = 0; - virtual ArgumentType getArgumentType(unsigned int i) const = 0; - virtual IfcSchema::Type::Enum getArgumentEntity(unsigned int i) const = 0; - virtual Argument* getArgument(unsigned int i) const = 0; - virtual const char* getArgumentName(unsigned int i) const = 0; + const IfcAbstractEntity& data() const { return *data_; } + IfcAbstractEntity& data() { return *data_; } + + void data(IfcAbstractEntity* d); + + virtual const IfcParse::declaration& declaration() const = 0; template T* as() { - return is(T::Class()) + return declaration().is(T::Class()) ? static_cast(this) : static_cast(0); } + + template + const T* as() const { + return declaration().is(T::Class()) + ? static_cast(this) + : static_cast(0); + } + private: + IfcBaseClass(const IfcBaseClass&); + IfcBaseClass& operator=(const IfcBaseClass&); }; class IfcBaseEntity : public IfcBaseClass { + public: + IfcBaseEntity() : IfcBaseClass() {} + IfcBaseEntity(IfcAbstractEntity* d) : IfcBaseClass(d) {} + + virtual const IfcParse::entity& declaration() const = 0; }; // TODO: Investigate whether these should be template classes instead - class IfcBaseType : public IfcBaseEntity { + class IfcBaseType : public IfcBaseClass { public: - unsigned int getArgumentCount() const; - Argument* getArgument(unsigned int i) const; - const char* getArgumentName(unsigned int i) const; - IfcSchema::Type::Enum getArgumentEntity(unsigned int i) const { return IfcSchema::Type::UNDEFINED; } + IfcBaseType() : IfcBaseClass() {} + IfcBaseType(IfcAbstractEntity* d) : IfcBaseClass(d) {} + + virtual const IfcParse::type_declaration& declaration() const = 0; }; bool valid_binary_string(const std::string& s); @@ -125,7 +151,7 @@ public: typename U::list::ptr as() { typename U::list::ptr r(new typename U::list); const bool all = U::Class() == IfcSchema::Type::UNDEFINED; - for ( it i = begin(); i != end(); ++ i ) if (all || (*i)->is(U::Class())) r->push((U*)*i); + for ( it i = begin(); i != end(); ++ i ) if (all || (*i)->declaration().is(U::Class())) r->push((U*)*i); return r; } void remove(IfcUtil::IfcBaseClass*); @@ -153,7 +179,7 @@ public: typename U::list::ptr as() { typename U::list::ptr r(new typename U::list); const bool all = U::Class() == IfcSchema::Type::UNDEFINED; - for ( it i = begin(); i != end(); ++ i ) if (all || (*i)->is(U::Class())) r->push((U*)*i); + for ( it i = begin(); i != end(); ++ i ) if (all || (*i)->declaration().is(U::Class())) r->push((U*)*i); return r; } void remove(T* t) { @@ -305,7 +331,8 @@ public: virtual IfcSchema::Type::Enum type() const = 0; virtual bool is(IfcSchema::Type::Enum v) const = 0; virtual std::string toString(bool upper=false) const = 0; - virtual unsigned int id() = 0; + virtual unsigned int id() const = 0; + virtual const IfcWrite::IfcWritableEntity* isWritable() const = 0; virtual IfcWrite::IfcWritableEntity* isWritable() = 0; }; @@ -325,7 +352,7 @@ public: static void Verbosity(Severity v); static Severity Verbosity(); /// Log a message to the output stream - static void Message(Severity type, const std::string& message, IfcAbstractEntity* entity=0); + static void Message(Severity type, const std::string& message, const IfcUtil::IfcBaseClass* instance=0); static void Status(const std::string& message, bool new_line=true); static void ProgressBar(int progress); static std::string GetLog(); diff --git a/src/ifcparse/IfcWritableEntity.h b/src/ifcparse/IfcWritableEntity.h index 20f1e57c20..e1c0d8610b 100644 --- a/src/ifcparse/IfcWritableEntity.h +++ b/src/ifcparse/IfcWritableEntity.h @@ -40,12 +40,17 @@ namespace IfcWrite { class IfcWritableEntity : public IfcAbstractEntity { private: + // Mutable because calling id() will generate a fresh id on + // the current file, in case none has been assigned previously + mutable int* _id; + std::map writemask; std::map args; IfcSchema::Type::Enum _type; - int* _id; + bool arg_writable(int i); void arg_writable(int i, bool b); + template void _setArgument(int i, const T&); public: IfcWritableEntity(IfcSchema::Type::Enum t); @@ -60,7 +65,8 @@ namespace IfcWrite { IfcSchema::Type::Enum type() const; bool is(IfcSchema::Type::Enum v) const; std::string toString(bool upper=false) const; - unsigned int id(); + unsigned int id() const; + const IfcWritableEntity* isWritable() const; IfcWritableEntity* isWritable(); void setArgument(int i, Argument* a); diff --git a/src/ifcparse/IfcWrite.cpp b/src/ifcparse/IfcWrite.cpp index 934651d3e6..010a3fea7e 100644 --- a/src/ifcparse/IfcWrite.cpp +++ b/src/ifcparse/IfcWrite.cpp @@ -109,12 +109,13 @@ std::string IfcWritableEntity::toString(bool upper) const { return ss.str(); } -unsigned int IfcWritableEntity::id() { +unsigned int IfcWritableEntity::id() const { if ( !_id ) { _id = new int(file->FreshId()); } return *_id; } +const IfcWritableEntity* IfcWritableEntity::isWritable() const { return this; } IfcWritableEntity* IfcWritableEntity::isWritable() { return this; } bool IfcWritableEntity::arg_writable(int i) { std::map::const_iterator it = writemask.find(i); @@ -390,11 +391,11 @@ public: data << "." << i.enumeration_value << "."; } void operator()(const IfcUtil::IfcBaseClass* const& i) { - IfcAbstractEntity* e = i->entity; - if ( IfcSchema::Type::IsSimple(e->type()) ) { - data << e->toString(upper); + const IfcAbstractEntity& e = i->data(); + if ( IfcSchema::Type::IsSimple(e.type()) ) { + data << e.toString(upper); } else { - data << "#" << e->id(); + data << "#" << e.id(); } } void operator()(const IfcEntityList::ptr& i) {